@accelint/map-toolkit 0.6.0 → 1.0.0

package/dist/map-cursor/store.d.ts

@@ -10,84 +10,55 @@
  * governing permissions and limitations under the License.
  */
 
+import { MapStore } from "../shared/create-map-store.js";
 import { CSSCursorType } from "./types.js";
 import { UniqueId } from "@accelint/core";
 
 //#region src/map-cursor/store.d.ts
 /**
- * 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 cursor state when the last subscriber unsubscribes.
- *
- * @param instanceId - The unique identifier for the map cursor instance
- * @returns A subscription function for useSyncExternalStore
+ * State shape for map cursor
  */
-declare function getOrCreateSubscription(instanceId: UniqueId): (onStoreChange: () => void) => () => void;
+type CursorState = {
+  /** Map of owner -> cursor */
+  cursorOwners: Map<string, CSSCursorType>;
+  /** Current active cursor (for priority tracking) */
+  currentCursor: CSSCursorType | null;
+  /** Current cursor owner (for priority tracking) */
+  currentOwner: string | null;
+};
 /**
- * Creates or retrieves a cached snapshot function for a given instanceId.
- * The cursor returned gets equality checked, so it needs to be stable or React re-renders unnecessarily.
- *
- * @param instanceId - The unique identifier for the map cursor instance
- * @returns A snapshot function for useSyncExternalStore
+ * Actions for cursor management
  */
-declare function getOrCreateSnapshot(instanceId: UniqueId): () => CSSCursorType;
+type CursorActions = {
+  /** Request a cursor change */
+  requestCursorChange: (cursor: CSSCursorType, owner: string) => void;
+  /** Clear cursor for an owner */
+  clearCursor: (owner: string) => void;
+};
 /**
- * Creates or retrieves a cached server snapshot function for a given instanceId.
- * Server snapshots always return the default cursor since cursor state is client-only.
- * Required for SSR/RSC compatibility with useSyncExternalStore.
- *
- * @param instanceId - The unique identifier for the map cursor instance
- * @returns A server snapshot function for useSyncExternalStore
+ * Cursor store
  */
-declare function getOrCreateServerSnapshot(instanceId: UniqueId): () => CSSCursorType;
+declare const cursorStore: MapStore<CursorState, CursorActions>;
 /**
- * Creates or retrieves a cached requestCursorChange function for a given instanceId.
- * This maintains referential stability for the function reference.
- *
- * @param instanceId - The unique identifier for the map cursor instance
- * @returns A requestCursorChange function for this instance
+ * Get effective cursor (computed from state)
  */
-declare function getOrCreateRequestCursorChange(instanceId: UniqueId): (cursor: CSSCursorType, owner: string) => void;
+declare function getCursor(mapId: UniqueId): CSSCursorType;
 /**
- * Creates or retrieves a cached clearCursor function for a given instanceId.
- * This maintains referential stability for the function reference.
+ * Hook for effective cursor value.
  *
- * @param instanceId - The unique identifier for the map cursor instance
- * @returns A clearCursor function for this instance
- */
-declare function getOrCreateClearCursor(instanceId: UniqueId): (owner: string) => void;
-/**
- * Get the current cursor for a given instance (direct access, not reactive).
- * @internal - For internal map-toolkit use only
+ * **Internal use only** - not exported from the public API.
+ * Use `useMapCursor` instead, which provides:
+ * - MapContext integration (auto-resolves mapId inside MapProvider)
+ * - Actions (requestCursorChange, clearCursor)
+ * - Better ergonomics for consumers
  *
- * @param instanceId - The unique identifier for the map instance
- * @returns The current cursor
+ * This hook exists for internal composition (used by useMapCursor).
  */
-declare function getCursor(instanceId: UniqueId): CSSCursorType;
+declare function useCursor(mapId: UniqueId): CSSCursorType;
 /**
- * Manually clear all cursor 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 cursor instance to clear
- *
- * @example
- * ```tsx
- * // Manual cleanup (rarely needed)
- * clearCursorState('my-map-instance');
- * ```
+ * Clear cursor state
  */
-declare function clearCursorState(instanceId: UniqueId): void;
-/** @deprecated Use module functions directly */
-declare function getOrCreateStore(id: UniqueId): {
-  getSnapshot: () => CSSCursorType;
-};
-/** @deprecated Use clearCursorState instead */
-declare function destroyStore(id: UniqueId): void;
-/** @deprecated Use direct function calls instead */
-declare function getStore(id: UniqueId): {
-  getSnapshot: () => CSSCursorType;
-} | undefined;
+declare function clearCursorState(mapId: UniqueId): void;
 //#endregion
-export { clearCursorState, destroyStore, getCursor, getOrCreateClearCursor, getOrCreateRequestCursorChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateStore, getOrCreateSubscription, getStore };
+export { clearCursorState, cursorStore, getCursor, useCursor };
 //# sourceMappingURL=store.d.ts.map

package/dist/map-cursor/store.js

@@ -11,98 +11,72 @@
  */
 
 
+import { createMapStore, mapDelete, mapSet } from "../shared/create-map-store.js";
 import { MapModeEvents } from "../map-mode/events.js";
-import { getCurrentModeOwner } from "../map-mode/store.js";
 import { MapCursorEvents } from "./events.js";
 import { Broadcast } from "@accelint/bus";
 
 //#region src/map-cursor/store.ts
 /**
-* Default cursor value
+* Map Cursor Store
+*
+* Manages cursor state with ownership-based priority.
+*
+* Priority order:
+* 1. Mode owner's cursor (if mode is owned)
+* 2. Most recent cursor request
+* 3. Default cursor
+*
+* @example
+* ```tsx
+* import { cursorStore } from '@accelint/map-toolkit/map-cursor';
+*
+* function MapContainer({ mapId }) {
+*   const cursor = cursorStore.useSelector(mapId, (s) => getEffectiveCursor(mapId, s));
+*   return <div style={{ cursor }}>...</div>;
+* }
+*
+* // Request cursor change from a layer:
+* cursorStore.actions(mapId).requestCursorChange('crosshair', 'draw-layer');
+* ```
 */
 const DEFAULT_CURSOR = "default";
+const cursorBus = Broadcast.getInstance();
+const modeBus = Broadcast.getInstance();
 /**
-* Typed event bus instance for map cursor events.
-* Provides type-safe event emission and listening for all map cursor state changes.
-*/
-const mapCursorBus = Broadcast.getInstance();
-/**
-* Store for map cursor state keyed by instanceId
-*/
-const cursorStore = /* @__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 cursor instance, 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 cursor since cursor state is client-only.
-*/
-const serverSnapshotCache = /* @__PURE__ */ new Map();
-/**
-* Cache of requestCursorChange functions per instanceId to maintain referential stability
-*/
-const requestCursorChangeCache = /* @__PURE__ */ new Map();
-/**
-* Cache of clearCursor functions per instanceId to maintain referential stability
-*/
-const clearCursorCache = /* @__PURE__ */ new Map();
-/**
-* All state caches that need cleanup when an instance is removed
-*/
-const stateCaches = [
-	cursorStore,
-	componentSubscribers,
-	subscriptionCache,
-	snapshotCache,
-	serverSnapshotCache,
-	requestCursorChangeCache,
-	clearCursorCache
-];
-/**
-* Clear all cached state for a given instanceId
-*/
-function clearAllCaches(instanceId) {
-	stateCaches.map((cache) => cache.delete(instanceId));
-}
-/**
-* Get or create cursor state for a given instanceId
-*/
-function getOrCreateState(instanceId) {
-	if (!cursorStore.has(instanceId)) cursorStore.set(instanceId, {
-		cursorOwners: /* @__PURE__ */ new Map(),
-		currentCursor: null,
-		currentOwner: null
+* Lazy import to avoid circular dependency between cursor and mode stores.
+* The mode store doesn't depend on cursor store, but importing it synchronously
+* at module load time can cause initialization order issues.
+*
+* This pattern ensures the import is resolved before first use (bus listeners
+* are set up on first subscriber, not at module load time).
+*/
+let getModeOwnerFn = null;
+let isRegisteredModeOwnerFn = null;
+let importPromise = null;
+let importFailed = false;
+function ensureModeStoreImported() {
+	if (getModeOwnerFn !== null || importFailed) return;
+	if (importPromise === null) importPromise = import("../map-mode/store.js").then((mod) => {
+		getModeOwnerFn = mod.getCurrentModeOwner;
+		isRegisteredModeOwnerFn = mod.isRegisteredModeOwner;
+	}).catch((error) => {
+		importFailed = true;
+		if (process.env.NODE_ENV !== "production") console.error("[MapCursor] Failed to import mode store:", error);
 	});
-	return cursorStore.get(instanceId);
+}
+ensureModeStoreImported();
+function getModeOwner(mapId) {
+	return getModeOwnerFn?.(mapId);
+}
+function isRegisteredOwner(mapId, owner) {
+	return isRegisteredModeOwnerFn?.(mapId, owner) ?? false;
 }
 /**
-* Get current cursor snapshot for a given instance (for useSyncExternalStore)
-*
-* Priority order:
-* 1. Mode owner's cursor (if exists and mode is owned)
-* 2. Most recent cursor (only if currentOwner still has an entry in storage)
-* 3. Default cursor
+* Calculate effective cursor based on priority
 */
-function getSnapshot(instanceId) {
-	const state = cursorStore.get(instanceId);
-	if (!state) return DEFAULT_CURSOR;
-	const modeOwner = getCurrentModeOwner(instanceId);
+function getEffectiveCursor(mapId, state) {
+	const modeOwner = getModeOwner?.(mapId);
 	if (modeOwner) {
 		const modeOwnerCursor = state.cursorOwners.get(modeOwner);
 		if (modeOwnerCursor) return modeOwnerCursor;
@@ -113,239 +87,136 @@ function getSnapshot(instanceId) {
 	return DEFAULT_CURSOR;
 }
 /**
-* Notify all React subscribers for a given instanceId
-*/
-function notifySubscribers(instanceId) {
-	const subscribers = componentSubscribers.get(instanceId);
-	if (subscribers) for (const onStoreChange of subscribers) onStoreChange();
-}
-/**
-* Handle cursor change request for a given instance
+* Cursor store
 */
-function handleCursorChangeRequest(instanceId, state, cursor, requestOwner) {
-	const previousCursor = getSnapshot(instanceId);
-	if (state.cursorOwners.get(requestOwner) === cursor) return;
-	state.cursorOwners.set(requestOwner, cursor);
-	const modeOwner = getCurrentModeOwner(instanceId);
-	if (!modeOwner || requestOwner === modeOwner) {
-		state.currentCursor = cursor;
-		state.currentOwner = requestOwner;
-		const newCursor = getSnapshot(instanceId);
-		if (previousCursor !== newCursor) {
-			mapCursorBus.emit(MapCursorEvents.changed, {
-				previousCursor,
-				currentCursor: newCursor,
-				owner: requestOwner,
-				id: instanceId
+const cursorStore = createMapStore({
+	defaultState: {
+		cursorOwners: /* @__PURE__ */ new Map(),
+		currentCursor: null,
+		currentOwner: null
+	},
+	actions: (mapId, { get, set }) => ({
+		requestCursorChange: (cursor, owner) => {
+			const trimmedCursor = cursor.trim();
+			const trimmedOwner = owner.trim();
+			if (!trimmedCursor) throw new Error("requestCursorChange requires non-empty cursor");
+			if (!trimmedOwner) throw new Error("requestCursorChange requires non-empty owner");
+			cursorBus.emit(MapCursorEvents.changeRequest, {
+				cursor: trimmedCursor,
+				owner: trimmedOwner,
+				id: mapId
 			});
-			notifySubscribers(instanceId);
-		}
-	} else mapCursorBus.emit(MapCursorEvents.rejected, {
-		rejectedCursor: cursor,
-		rejectedOwner: requestOwner,
-		currentOwner: state.currentOwner || modeOwner || "unknown",
-		reason: "not-owner",
-		id: instanceId
-	});
-}
-/**
-* Ensures a single bus listener exists for the given instanceId.
-* All React subscribers will be notified via fan-out when the bus events fire.
-* This prevents creating N bus listeners for N React components.
-*
-* @param instanceId - The unique identifier for the map cursor instance
-*/
-function ensureBusListener(instanceId) {
-	if (busUnsubscribers.has(instanceId)) return;
-	const state = getOrCreateState(instanceId);
-	const unsubRequest = mapCursorBus.on(MapCursorEvents.changeRequest, (event) => {
-		const { cursor, owner: requestOwner, id } = event.payload;
-		if (id !== instanceId) return;
-		handleCursorChangeRequest(instanceId, state, cursor, requestOwner);
-	});
-	const unsubModeChange = Broadcast.getInstance().on(MapModeEvents.changed, (event) => {
-		if (event.payload.id !== instanceId) return;
-		const previousCursor = getSnapshot(instanceId);
-		if (event.payload.currentMode === "default" || event.payload.previousMode !== event.payload.currentMode) {
-			state.currentCursor = null;
-			state.currentOwner = null;
-			notifySubscribers(instanceId);
+		},
+		clearCursor: (owner) => {
+			const state = get();
+			if (state.cursorOwners.has(owner)) {
+				const updates = { cursorOwners: mapDelete(state.cursorOwners, owner) };
+				if (state.currentOwner === owner) {
+					updates.currentCursor = null;
+					updates.currentOwner = null;
+				}
+				set(updates);
+			}
 		}
-		queueMicrotask(() => {
-			const newCursor = getSnapshot(instanceId);
-			if (previousCursor !== newCursor) {
-				const newModeOwner = getCurrentModeOwner(instanceId) || "system";
-				mapCursorBus.emit(MapCursorEvents.changed, {
-					previousCursor,
-					currentCursor: newCursor,
-					owner: newModeOwner,
-					id: instanceId
+	}),
+	bus: (mapId, { get, set }) => {
+		const unsubRequest = cursorBus.on(MapCursorEvents.changeRequest, (event) => {
+			const { cursor, owner: requestOwner, id } = event.payload;
+			if (id !== mapId) return;
+			const state = get();
+			const previousCursor = getEffectiveCursor(mapId, state);
+			if (state.cursorOwners.get(requestOwner) === cursor) return;
+			const newCursorOwners = mapSet(state.cursorOwners, requestOwner, cursor);
+			const currentModeOwner = getModeOwner?.(mapId);
+			const isOwnerless = !currentModeOwner;
+			const isCurrentModeOwner = requestOwner === currentModeOwner;
+			const isAnyModeOwner = isRegisteredOwner(mapId, requestOwner);
+			if (isOwnerless || isCurrentModeOwner) {
+				const newState = {
+					cursorOwners: newCursorOwners,
+					currentCursor: cursor,
+					currentOwner: requestOwner
+				};
+				const newCursor = getEffectiveCursor(mapId, newState);
+				if (previousCursor !== newCursor) {
+					set(newState);
+					cursorBus.emit(MapCursorEvents.changed, {
+						previousCursor,
+						currentCursor: newCursor,
+						owner: requestOwner,
+						id: mapId
+					});
+				} else set(newState);
+			} else if (isAnyModeOwner) {
+				set({ cursorOwners: newCursorOwners });
+				cursorBus.emit(MapCursorEvents.rejected, {
+					rejectedCursor: cursor,
+					rejectedOwner: requestOwner,
+					currentOwner: state.currentOwner || currentModeOwner || "unknown",
+					reason: "not-current-owner",
+					id: mapId
 				});
-				notifySubscribers(instanceId);
-			}
+			} else cursorBus.emit(MapCursorEvents.rejected, {
+				rejectedCursor: cursor,
+				rejectedOwner: requestOwner,
+				currentOwner: state.currentOwner || currentModeOwner || "unknown",
+				reason: "not-owner",
+				id: mapId
+			});
+		});
+		const unsubMode = modeBus.on(MapModeEvents.changed, (event) => {
+			if (event.payload.id !== mapId) return;
+			const previousCursor = getEffectiveCursor(mapId, get());
+			if (event.payload.currentMode === "default" || event.payload.previousMode !== event.payload.currentMode) set({
+				currentCursor: null,
+				currentOwner: null
+			});
+			queueMicrotask(() => {
+				const newCursor = getEffectiveCursor(mapId, get());
+				if (previousCursor !== newCursor) {
+					const newModeOwner = getModeOwner?.(mapId) || "system";
+					cursorBus.emit(MapCursorEvents.changed, {
+						previousCursor,
+						currentCursor: newCursor,
+						owner: newModeOwner,
+						id: mapId
+					});
+				}
+			});
 		});
-	});
-	busUnsubscribers.set(instanceId, () => {
-		unsubRequest();
-		unsubModeChange();
-	});
-}
-/**
-* Cleans up the bus listener if no React subscribers remain.
-*
-* @param instanceId - The unique identifier for the map cursor instance
-*/
-function cleanupBusListenerIfNeeded(instanceId) {
-	const subscribers = componentSubscribers.get(instanceId);
-	if (!subscribers || subscribers.size === 0) {
-		const unsub = busUnsubscribers.get(instanceId);
-		if (unsub) {
-			unsub();
-			busUnsubscribers.delete(instanceId);
-		}
-		clearAllCaches(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 cursor state when the last subscriber unsubscribes.
-*
-* @param instanceId - The unique identifier for the map cursor instance
-* @returns A subscription function for useSyncExternalStore
-*/
-function getOrCreateSubscription(instanceId) {
-	const subscription = subscriptionCache.get(instanceId) ?? ((onStoreChange) => {
-		getOrCreateState(instanceId);
-		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);
+			unsubRequest();
+			unsubMode();
 		};
-	});
-	subscriptionCache.set(instanceId, subscription);
-	return subscription;
-}
-/**
-* Creates or retrieves a cached snapshot function for a given instanceId.
-* The cursor returned gets equality checked, so it needs to be stable or React re-renders unnecessarily.
-*
-* @param instanceId - The unique identifier for the map cursor instance
-* @returns A snapshot function for useSyncExternalStore
-*/
-function getOrCreateSnapshot(instanceId) {
-	const snapshot = snapshotCache.get(instanceId) ?? (() => getSnapshot(instanceId));
-	snapshotCache.set(instanceId, snapshot);
-	return snapshot;
-}
+	}
+});
 /**
-* Creates or retrieves a cached server snapshot function for a given instanceId.
-* Server snapshots always return the default cursor since cursor state is client-only.
-* Required for SSR/RSC compatibility with useSyncExternalStore.
-*
-* @param instanceId - The unique identifier for the map cursor instance
-* @returns A server snapshot function for useSyncExternalStore
+* Get effective cursor (computed from state)
 */
-function getOrCreateServerSnapshot(instanceId) {
-	const serverSnapshot = serverSnapshotCache.get(instanceId) ?? (() => DEFAULT_CURSOR);
-	serverSnapshotCache.set(instanceId, serverSnapshot);
-	return serverSnapshot;
+function getCursor(mapId) {
+	return getEffectiveCursor(mapId, cursorStore.get(mapId));
 }
 /**
-* Creates or retrieves a cached requestCursorChange function for a given instanceId.
-* This maintains referential stability for the function reference.
+* Hook for effective cursor value.
 *
-* @param instanceId - The unique identifier for the map cursor instance
-* @returns A requestCursorChange function for this instance
-*/
-function getOrCreateRequestCursorChange(instanceId) {
-	const requestCursorChange = requestCursorChangeCache.get(instanceId) ?? ((cursor, owner) => {
-		const trimmedCursor = cursor.trim();
-		const trimmedOwner = owner.trim();
-		if (!trimmedCursor) throw new Error("requestCursorChange requires non-empty cursor");
-		if (!trimmedOwner) throw new Error("requestCursorChange requires non-empty owner");
-		mapCursorBus.emit(MapCursorEvents.changeRequest, {
-			cursor: trimmedCursor,
-			owner: trimmedOwner,
-			id: instanceId
-		});
-	});
-	requestCursorChangeCache.set(instanceId, requestCursorChange);
-	return requestCursorChange;
-}
-/**
-* Creates or retrieves a cached clearCursor function for a given instanceId.
-* This maintains referential stability for the function reference.
+* **Internal use only** - not exported from the public API.
+* Use `useMapCursor` instead, which provides:
+* - MapContext integration (auto-resolves mapId inside MapProvider)
+* - Actions (requestCursorChange, clearCursor)
+* - Better ergonomics for consumers
 *
-* @param instanceId - The unique identifier for the map cursor instance
-* @returns A clearCursor function for this instance
+* This hook exists for internal composition (used by useMapCursor).
 */
-function getOrCreateClearCursor(instanceId) {
-	const clearCursor = clearCursorCache.get(instanceId) ?? ((owner) => {
-		const state = cursorStore.get(instanceId);
-		if (!state) return;
-		const hadCursor = state.cursorOwners.has(owner);
-		state.cursorOwners.delete(owner);
-		if (state.currentOwner === owner) {
-			state.currentCursor = null;
-			state.currentOwner = null;
-		}
-		if (hadCursor) notifySubscribers(instanceId);
-	});
-	clearCursorCache.set(instanceId, clearCursor);
-	return clearCursor;
+function useCursor(mapId) {
+	return cursorStore.useSelector(mapId, (state) => getEffectiveCursor(mapId, state));
 }
 /**
-* Get the current cursor for a given instance (direct access, not reactive).
-* @internal - For internal map-toolkit use only
-*
-* @param instanceId - The unique identifier for the map instance
-* @returns The current cursor
+* Clear cursor state
 */
-function getCursor(instanceId) {
-	return getSnapshot(instanceId);
-}
-/**
-* Manually clear all cursor 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 cursor instance to clear
-*
-* @example
-* ```tsx
-* // Manual cleanup (rarely needed)
-* clearCursorState('my-map-instance');
-* ```
-*/
-function clearCursorState(instanceId) {
-	const unsub = busUnsubscribers.get(instanceId);
-	if (unsub) {
-		unsub();
-		busUnsubscribers.delete(instanceId);
-	}
-	clearAllCaches(instanceId);
-}
-/** @deprecated Use module functions directly */
-function getOrCreateStore(id) {
-	return { getSnapshot: () => getSnapshot(id) };
-}
-/** @deprecated Use clearCursorState instead */
-function destroyStore(id) {
-	clearCursorState(id);
-}
-/** @deprecated Use direct function calls instead */
-function getStore(id) {
-	return { getSnapshot: () => getSnapshot(id) };
+function clearCursorState(mapId) {
+	cursorStore.clear(mapId);
 }
 
 //#endregion
-export { clearCursorState, destroyStore, getCursor, getOrCreateClearCursor, getOrCreateRequestCursorChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateStore, getOrCreateSubscription, getStore };
+export { clearCursorState, cursorStore, getCursor, useCursor };
 //# sourceMappingURL=store.js.map