@accelint/map-toolkit 0.6.0 → 1.1.0

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

@@ -13,9 +13,9 @@
 
 'use client';
 
-import { getOrCreateClearCursor, getOrCreateRequestCursorChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateSubscription } from "./store.js";
+import { cursorStore, useCursor } from "./store.js";
 import { MapContext } from "../deckgl/base-map/provider.js";
-import { useContext, useEffect, useMemo, useSyncExternalStore } from "react";
+import { useContext, useEffect, useMemo, useRef } from "react";
 
 //#region src/map-cursor/use-map-cursor.ts
 /**
@@ -70,12 +70,13 @@ function useMapCursor(id) {
 	const contextId = useContext(MapContext);
 	const actualId = id ?? contextId;
 	if (!actualId) throw new Error("useMapCursor requires either an id parameter or to be used within a MapProvider");
-	const cursor = useSyncExternalStore(getOrCreateSubscription(actualId), getOrCreateSnapshot(actualId), getOrCreateServerSnapshot(actualId));
+	const cursor = useCursor(actualId);
+	const actions = useMemo(() => cursorStore.actions(actualId), [actualId]);
 	return useMemo(() => ({
 		cursor,
-		requestCursorChange: getOrCreateRequestCursorChange(actualId),
-		clearCursor: getOrCreateClearCursor(actualId)
-	}), [cursor, actualId]);
+		requestCursorChange: actions.requestCursorChange,
+		clearCursor: actions.clearCursor
+	}), [cursor, actions]);
 }
 /**
 * Hook to automatically manage cursor for a component's lifecycle.
@@ -83,7 +84,10 @@ function useMapCursor(id) {
 * This hook automatically requests a cursor when mounted and clears it when unmounted.
 * Useful for components that need to consistently show a specific cursor.
 *
-* @param cursor - The cursor to request
+* NOTE: This hook does NOT re-render when cursor state changes. If you need to read
+* the current cursor value, use `useMapCursor` instead.
+*
+* @param cursorType - The cursor to request
 * @param owner - The owner identifier
 * @param id - Optional map instance ID
 *
@@ -96,18 +100,32 @@ function useMapCursor(id) {
 * }
 * ```
 */
-function useMapCursorEffect(cursor, owner, id) {
-	const { requestCursorChange, clearCursor } = useMapCursor(id);
+function useMapCursorEffect(cursorType, owner, id) {
+	const contextId = useContext(MapContext);
+	const actualId = id ?? contextId;
+	if (!actualId) throw new Error("useMapCursorEffect requires either an id parameter or to be used within a MapProvider");
+	const cursorRef = useRef(cursorType);
+	const ownerRef = useRef(owner);
+	const idRef = useRef(actualId);
+	cursorRef.current = cursorType;
+	ownerRef.current = owner;
+	idRef.current = actualId;
 	useEffect(() => {
-		requestCursorChange(cursor, owner);
+		const mapId = idRef.current;
+		const unsubscribe = cursorStore.subscribe(mapId)(() => {});
 		return () => {
-			clearCursor(owner);
+			unsubscribe();
+			queueMicrotask(() => {
+				cursorStore.actions(idRef.current).clearCursor(ownerRef.current);
+			});
 		};
+	}, []);
+	useEffect(() => {
+		cursorStore.actions(actualId).requestCursorChange(cursorType, owner);
 	}, [
-		cursor,
-		owner,
-		requestCursorChange,
-		clearCursor
+		actualId,
+		cursorType,
+		owner
 	]);
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"use-map-cursor.js","names":[],"sources":["../../src/map-cursor/use-map-cursor.ts"],"sourcesContent":["/*\n * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n'use client';\n\nimport 'client-only';\nimport { useContext, useEffect, useMemo, useSyncExternalStore } from 'react';\nimport { MapContext } from '../deckgl/base-map/provider';\nimport {\n  getOrCreateClearCursor,\n  getOrCreateRequestCursorChange,\n  getOrCreateServerSnapshot,\n  getOrCreateSnapshot,\n  getOrCreateSubscription,\n} from './store';\nimport type { UniqueId } from '@accelint/core';\nimport type { CSSCursorType } from './types';\n\n/**\n * Return value for the useMapCursor hook\n */\nexport type UseMapCursorReturn = {\n  /** The current active cursor */\n  cursor: CSSCursorType;\n  /** Function to request a cursor change with ownership */\n  requestCursorChange: (cursor: CSSCursorType, requestOwner: string) => void;\n  /** Function to clear cursor for an owner */\n  clearCursor: (owner: string) => void;\n};\n\n/**\n * Hook to access the map cursor state and actions.\n *\n * This hook uses `useSyncExternalStore` to subscribe to map cursor state changes,\n * providing concurrent-safe cursor state updates. Uses a fan-out pattern where\n * a single bus listener per map instance notifies N React component subscribers.\n *\n * **Owner-based Priority System:**\n * - Mode owners (from MapModeStore) have highest priority\n * - Non-owners can set cursors only in default/ownerless modes\n * - Rejected requests emit events with rejection reasons\n *\n * @param id - Optional map instance ID. If not provided, will use the ID from `MapContext`.\n * @returns The current cursor, requestCursorChange function, and clearCursor function\n * @throws Error if no `id` is provided and hook is used outside of `MapProvider`\n *\n * @example\n * ```tsx\n * // Inside MapProvider (within BaseMap children)\n * function CustomDeckLayer() {\n *   const { cursor, requestCursorChange, clearCursor } = useMapCursor();\n *\n *   const handleHover = (info: PickingInfo) => {\n *     if (info.object) {\n *       requestCursorChange('pointer', 'custom-layer-id');\n *     } else {\n *       clearCursor('custom-layer-id');\n *     }\n *   };\n *\n *   return <ScatterplotLayer onHover={handleHover} />;\n * }\n * ```\n *\n * @example\n * ```tsx\n * // Outside MapProvider - pass id directly\n * function ExternalControl({ mapId }: { mapId: UniqueId }) {\n *   const { cursor, requestCursorChange } = useMapCursor(mapId);\n *\n *   return (\n *     <button onClick={() => requestCursorChange('crosshair', 'external-control')}>\n *       Set Crosshair (current: {cursor})\n *     </button>\n *   );\n * }\n * ```\n */\nexport function useMapCursor(id?: UniqueId): UseMapCursorReturn {\n  const contextId = useContext(MapContext);\n  const actualId = id ?? contextId;\n\n  if (!actualId) {\n    throw new Error(\n      'useMapCursor requires either an id parameter or to be used within a MapProvider',\n    );\n  }\n\n  // Subscribe to store using useSyncExternalStore with fan-out pattern\n  // Third parameter provides server snapshot for SSR/RSC compatibility\n  const cursor = useSyncExternalStore(\n    getOrCreateSubscription(actualId),\n    getOrCreateSnapshot(actualId),\n    getOrCreateServerSnapshot(actualId),\n  );\n\n  // Memoize the return value to prevent unnecessary re-renders\n  return useMemo(\n    () => ({\n      cursor,\n      requestCursorChange: getOrCreateRequestCursorChange(actualId),\n      clearCursor: getOrCreateClearCursor(actualId),\n    }),\n    [cursor, actualId],\n  );\n}\n\n/**\n * Hook to automatically manage cursor for a component's lifecycle.\n *\n * This hook automatically requests a cursor when mounted and clears it when unmounted.\n * Useful for components that need to consistently show a specific cursor.\n *\n * @param cursor - The cursor to request\n * @param owner - The owner identifier\n * @param id - Optional map instance ID\n *\n * @example\n * ```tsx\n * function DrawingMode() {\n *   useMapCursorEffect('crosshair', 'drawing-mode');\n *\n *   return <div>Drawing mode active with crosshair cursor</div>;\n * }\n * ```\n */\nexport function useMapCursorEffect(\n  cursor: CSSCursorType,\n  owner: string,\n  id?: UniqueId,\n): void {\n  const { requestCursorChange, clearCursor } = useMapCursor(id);\n\n  useEffect(() => {\n    requestCursorChange(cursor, owner);\n\n    return () => {\n      clearCursor(owner);\n    };\n  }, [cursor, owner, requestCursorChange, clearCursor]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,SAAgB,aAAa,IAAmC;CAC9D,MAAM,YAAY,WAAW,WAAW;CACxC,MAAM,WAAW,MAAM;AAEvB,KAAI,CAAC,SACH,OAAM,IAAI,MACR,kFACD;CAKH,MAAM,SAAS,qBACb,wBAAwB,SAAS,EACjC,oBAAoB,SAAS,EAC7B,0BAA0B,SAAS,CACpC;AAGD,QAAO,eACE;EACL;EACA,qBAAqB,+BAA+B,SAAS;EAC7D,aAAa,uBAAuB,SAAS;EAC9C,GACD,CAAC,QAAQ,SAAS,CACnB;;;;;;;;;;;;;;;;;;;;;AAsBH,SAAgB,mBACd,QACA,OACA,IACM;CACN,MAAM,EAAE,qBAAqB,gBAAgB,aAAa,GAAG;AAE7D,iBAAgB;AACd,sBAAoB,QAAQ,MAAM;AAElC,eAAa;AACX,eAAY,MAAM;;IAEnB;EAAC;EAAQ;EAAO;EAAqB;EAAY,CAAC"}
+{"version":3,"file":"use-map-cursor.js","names":[],"sources":["../../src/map-cursor/use-map-cursor.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n'use client';\n\nimport 'client-only';\nimport { useContext, useEffect, useMemo, useRef } from 'react';\nimport { MapContext } from '../deckgl/base-map/provider';\nimport { cursorStore, useCursor } from './store';\nimport type { UniqueId } from '@accelint/core';\nimport type { CSSCursorType } from './types';\n\n/**\n * Return value for the useMapCursor hook\n */\nexport type UseMapCursorReturn = {\n  /** The current active cursor */\n  cursor: CSSCursorType;\n  /** Function to request a cursor change with ownership */\n  requestCursorChange: (cursor: CSSCursorType, requestOwner: string) => void;\n  /** Function to clear cursor for an owner */\n  clearCursor: (owner: string) => void;\n};\n\n/**\n * Hook to access the map cursor state and actions.\n *\n * This hook uses `useSyncExternalStore` to subscribe to map cursor state changes,\n * providing concurrent-safe cursor state updates. Uses a fan-out pattern where\n * a single bus listener per map instance notifies N React component subscribers.\n *\n * **Owner-based Priority System:**\n * - Mode owners (from MapModeStore) have highest priority\n * - Non-owners can set cursors only in default/ownerless modes\n * - Rejected requests emit events with rejection reasons\n *\n * @param id - Optional map instance ID. If not provided, will use the ID from `MapContext`.\n * @returns The current cursor, requestCursorChange function, and clearCursor function\n * @throws Error if no `id` is provided and hook is used outside of `MapProvider`\n *\n * @example\n * ```tsx\n * // Inside MapProvider (within BaseMap children)\n * function CustomDeckLayer() {\n *   const { cursor, requestCursorChange, clearCursor } = useMapCursor();\n *\n *   const handleHover = (info: PickingInfo) => {\n *     if (info.object) {\n *       requestCursorChange('pointer', 'custom-layer-id');\n *     } else {\n *       clearCursor('custom-layer-id');\n *     }\n *   };\n *\n *   return <ScatterplotLayer onHover={handleHover} />;\n * }\n * ```\n *\n * @example\n * ```tsx\n * // Outside MapProvider - pass id directly\n * function ExternalControl({ mapId }: { mapId: UniqueId }) {\n *   const { cursor, requestCursorChange } = useMapCursor(mapId);\n *\n *   return (\n *     <button onClick={() => requestCursorChange('crosshair', 'external-control')}>\n *       Set Crosshair (current: {cursor})\n *     </button>\n *   );\n * }\n * ```\n */\nexport function useMapCursor(id?: UniqueId): UseMapCursorReturn {\n  const contextId = useContext(MapContext);\n  const actualId = id ?? contextId;\n\n  if (!actualId) {\n    throw new Error(\n      'useMapCursor requires either an id parameter or to be used within a MapProvider',\n    );\n  }\n\n  // Use the useCursor hook which computes effective cursor with priority\n  const cursor = useCursor(actualId);\n\n  // Get actions from the store - cursorStore.actions returns stable references\n  // (cached per mapId), so we can memoize on actualId only\n  const actions = useMemo(() => cursorStore.actions(actualId), [actualId]);\n\n  // Memoize the return value to prevent unnecessary re-renders\n  return useMemo(\n    () => ({\n      cursor,\n      requestCursorChange: actions.requestCursorChange,\n      clearCursor: actions.clearCursor,\n    }),\n    [cursor, actions],\n  );\n}\n\n/**\n * Hook to automatically manage cursor for a component's lifecycle.\n *\n * This hook automatically requests a cursor when mounted and clears it when unmounted.\n * Useful for components that need to consistently show a specific cursor.\n *\n * NOTE: This hook does NOT re-render when cursor state changes. If you need to read\n * the current cursor value, use `useMapCursor` instead.\n *\n * @param cursorType - The cursor to request\n * @param owner - The owner identifier\n * @param id - Optional map instance ID\n *\n * @example\n * ```tsx\n * function DrawingMode() {\n *   useMapCursorEffect('crosshair', 'drawing-mode');\n *\n *   return <div>Drawing mode active with crosshair cursor</div>;\n * }\n * ```\n */\nexport function useMapCursorEffect(\n  cursorType: CSSCursorType,\n  owner: string,\n  id?: UniqueId,\n): void {\n  const contextId = useContext(MapContext);\n  const actualId = id ?? contextId;\n\n  if (!actualId) {\n    throw new Error(\n      'useMapCursorEffect requires either an id parameter or to be used within a MapProvider',\n    );\n  }\n\n  // Store values in refs for stable cleanup function access\n  const cursorRef = useRef(cursorType);\n  const ownerRef = useRef(owner);\n  const idRef = useRef(actualId);\n\n  // Update refs on each render\n  cursorRef.current = cursorType;\n  ownerRef.current = owner;\n  idRef.current = actualId;\n\n  // Subscribe to store (to ensure bus listeners are set up) on mount only\n  useEffect(() => {\n    const mapId = idRef.current;\n\n    // Subscribe to store to ensure bus listeners are set up\n    // The subscription callback is a no-op since we don't want to re-render\n    const unsubscribe = cursorStore.subscribe(mapId)(() => {\n      // No-op: we don't want cursor state changes to trigger re-renders\n    });\n\n    return () => {\n      // Unsubscribe first to prevent re-render loops\n      unsubscribe();\n\n      // IMPORTANT: Defer cursor clear using queueMicrotask to avoid the React error:\n      // \"Cannot update a component while rendering a different component\"\n      //\n      // Effect cleanup runs during React's commit phase. If clearCursor() triggers\n      // a state update synchronously (via store.set() -> notify subscribers), it can\n      // cause React to attempt re-rendering while still committing the current tree.\n      //\n      // queueMicrotask schedules the cleanup to run after the current commit phase\n      // completes, allowing React to finish its work before the state update occurs.\n      queueMicrotask(() => {\n        const cleanupActions = cursorStore.actions(idRef.current);\n        cleanupActions.clearCursor(ownerRef.current);\n      });\n    };\n  }, []);\n\n  // Request cursor when cursorType or owner changes\n  useEffect(() => {\n    const actions = cursorStore.actions(actualId);\n    actions.requestCursorChange(cursorType, owner);\n  }, [actualId, cursorType, owner]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,aAAa,IAAmC;CAC9D,MAAM,YAAY,WAAW,WAAW;CACxC,MAAM,WAAW,MAAM;AAEvB,KAAI,CAAC,SACH,OAAM,IAAI,MACR,kFACD;CAIH,MAAM,SAAS,UAAU,SAAS;CAIlC,MAAM,UAAU,cAAc,YAAY,QAAQ,SAAS,EAAE,CAAC,SAAS,CAAC;AAGxE,QAAO,eACE;EACL;EACA,qBAAqB,QAAQ;EAC7B,aAAa,QAAQ;EACtB,GACD,CAAC,QAAQ,QAAQ,CAClB;;;;;;;;;;;;;;;;;;;;;;;;AAyBH,SAAgB,mBACd,YACA,OACA,IACM;CACN,MAAM,YAAY,WAAW,WAAW;CACxC,MAAM,WAAW,MAAM;AAEvB,KAAI,CAAC,SACH,OAAM,IAAI,MACR,wFACD;CAIH,MAAM,YAAY,OAAO,WAAW;CACpC,MAAM,WAAW,OAAO,MAAM;CAC9B,MAAM,QAAQ,OAAO,SAAS;AAG9B,WAAU,UAAU;AACpB,UAAS,UAAU;AACnB,OAAM,UAAU;AAGhB,iBAAgB;EACd,MAAM,QAAQ,MAAM;EAIpB,MAAM,cAAc,YAAY,UAAU,MAAM,OAAO,GAErD;AAEF,eAAa;AAEX,gBAAa;AAWb,wBAAqB;AAEnB,IADuB,YAAY,QAAQ,MAAM,QAAQ,CAC1C,YAAY,SAAS,QAAQ;KAC5C;;IAEH,EAAE,CAAC;AAGN,iBAAgB;AAEd,EADgB,YAAY,QAAQ,SAAS,CACrC,oBAAoB,YAAY,MAAM;IAC7C;EAAC;EAAU;EAAY;EAAM,CAAC"}

package/dist/map-mode/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","names":[],"sources":["../../src/map-mode/events.ts"],"sourcesContent":["/*\n * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\n/**\n * Namespace prefix for all map mode events.\n */\nexport const MapModeEventsNamespace = 'map-mode';\n\n/**\n * Event type constants for map mode state management.\n *\n * These events are emitted through the `@accelint/bus` event bus to coordinate\n * map mode changes across components in a decoupled manner.\n *\n * @example\n * ```ts\n * import { useOn, useEmit } from '@accelint/bus/react';\n * import { MapModeEvents } from '@accelint/map-toolkit/map-mode';\n *\n * // Listen for mode changes\n * useOn(MapModeEvents.changed, (event) => {\n *   console.log('Mode changed to:', event.payload.currentMode);\n * });\n *\n * // Emit a decision\n * const emitDecision = useEmit(MapModeEvents.changeDecision);\n * emitDecision({ authId, approved: true, owner: 'my-id', id });\n * ```\n */\nexport const MapModeEvents = {\n  /** Emitted when the map mode has successfully changed */\n  changed: `${MapModeEventsNamespace}:changed`,\n  /** Emitted when a component requests a mode change */\n  changeRequest: `${MapModeEventsNamespace}:change:request`,\n  /** Emitted when authorization is required for a mode change */\n  changeAuthorization: `${MapModeEventsNamespace}:change:authorization`,\n  /** Emitted when an authorization decision is made (approve/reject) */\n  changeDecision: `${MapModeEventsNamespace}:change:decision`,\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;;;;AAuBtC,MAAa,gBAAgB;CAE3B,SAAS,GAAG,uBAAuB;CAEnC,eAAe,GAAG,uBAAuB;CAEzC,qBAAqB,GAAG,uBAAuB;CAE/C,gBAAgB,GAAG,uBAAuB;CAC3C"}
+{"version":3,"file":"events.js","names":[],"sources":["../../src/map-mode/events.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\n/**\n * Namespace prefix for all map mode events.\n */\nexport const MapModeEventsNamespace = 'map-mode';\n\n/**\n * Event type constants for map mode state management.\n *\n * These events are emitted through the `@accelint/bus` event bus to coordinate\n * map mode changes across components in a decoupled manner.\n *\n * @example\n * ```ts\n * import { useOn, useEmit } from '@accelint/bus/react';\n * import { MapModeEvents } from '@accelint/map-toolkit/map-mode';\n *\n * // Listen for mode changes\n * useOn(MapModeEvents.changed, (event) => {\n *   console.log('Mode changed to:', event.payload.currentMode);\n * });\n *\n * // Emit a decision\n * const emitDecision = useEmit(MapModeEvents.changeDecision);\n * emitDecision({ authId, approved: true, owner: 'my-id', id });\n * ```\n */\nexport const MapModeEvents = {\n  /** Emitted when the map mode has successfully changed */\n  changed: `${MapModeEventsNamespace}:changed`,\n  /** Emitted when a component requests a mode change */\n  changeRequest: `${MapModeEventsNamespace}:change:request`,\n  /** Emitted when authorization is required for a mode change */\n  changeAuthorization: `${MapModeEventsNamespace}:change:authorization`,\n  /** Emitted when an authorization decision is made (approve/reject) */\n  changeDecision: `${MapModeEventsNamespace}:change:decision`,\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;;;;AAuBtC,MAAa,gBAAgB;CAE3B,SAAS,GAAG,uBAAuB;CAEnC,eAAe,GAAG,uBAAuB;CAEzC,qBAAqB,GAAG,uBAAuB;CAE/C,gBAAgB,GAAG,uBAAuB;CAC3C"}

package/dist/map-mode/index.d.ts

@@ -11,7 +11,7 @@
  */
 
 import { MapModeEvents, MapModeEventsNamespace } from "./events.js";
-import { clearMapModeState, getCurrentModeOwner } from "./store.js";
+import { clearMapModeState, getCurrentModeOwner, getMode, modeStore } from "./store.js";
 import { UseMapModeReturn, useMapMode } from "./use-map-mode.js";
 import { MapModeEventType, ModeChangeAuthorizationEvent, ModeChangeAuthorizationPayload, ModeChangeDecisionEvent, ModeChangeDecisionPayload, ModeChangeRequestEvent, ModeChangeRequestPayload, ModeChangedEvent, ModeChangedPayload } from "./types.js";
-export { type MapModeEventType, MapModeEvents, MapModeEventsNamespace, type ModeChangeAuthorizationEvent, type ModeChangeAuthorizationPayload, type ModeChangeDecisionEvent, type ModeChangeDecisionPayload, type ModeChangeRequestEvent, type ModeChangeRequestPayload, type ModeChangedEvent, type ModeChangedPayload, type UseMapModeReturn, clearMapModeState, getCurrentModeOwner, useMapMode };
+export { type MapModeEventType, MapModeEvents, MapModeEventsNamespace, type ModeChangeAuthorizationEvent, type ModeChangeAuthorizationPayload, type ModeChangeDecisionEvent, type ModeChangeDecisionPayload, type ModeChangeRequestEvent, type ModeChangeRequestPayload, type ModeChangedEvent, type ModeChangedPayload, type UseMapModeReturn, clearMapModeState, getCurrentModeOwner, getMode, modeStore, useMapMode };

package/dist/map-mode/index.js

@@ -12,7 +12,7 @@
 
 
 import { MapModeEvents, MapModeEventsNamespace } from "./events.js";
-import { clearMapModeState, getCurrentModeOwner } from "./store.js";
+import { clearMapModeState, getCurrentModeOwner, getMode, modeStore } from "./store.js";
 import { useMapMode } from "./use-map-mode.js";
 
-export { MapModeEvents, MapModeEventsNamespace, clearMapModeState, getCurrentModeOwner, useMapMode };
+export { MapModeEvents, MapModeEventsNamespace, clearMapModeState, getCurrentModeOwner, getMode, modeStore, useMapMode };

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

@@ -10,62 +10,61 @@
  * governing permissions and limitations under the License.
  */
 
+import { MapStore } from "../shared/create-map-store.js";
 import { UniqueId } from "@accelint/core";
 
 //#region src/map-mode/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 map mode state when the last subscriber unsubscribes.
- *
- * @param instanceId - The unique identifier for the map mode instance
- * @returns A subscription function for useSyncExternalStore
+ * Internal type for tracking pending authorization requests.
  */
-declare function getOrCreateSubscription(instanceId: UniqueId): (onStoreChange: () => void) => () => void;
+type PendingRequest = {
+  authId: string;
+  desiredMode: string;
+  currentMode: string;
+  requestOwner: string;
+};
 /**
- * Creates or retrieves a cached snapshot function for a given instanceId.
- * The string returned gets equality checked, so it needs to be stable or React re-renders unnecessarily.
- *
- * @param instanceId - The unique identifier for the map mode instance
- * @returns A snapshot function for useSyncExternalStore
+ * State shape for map mode
  */
-declare function getOrCreateSnapshot(instanceId: UniqueId): () => string;
+type MapModeState = {
+  mode: string;
+  modeOwners: Map<string, string>;
+  pendingRequests: Map<string, PendingRequest>;
+};
 /**
- * Creates or retrieves a cached server snapshot function for a given instanceId.
- * Server snapshots always return the default mode since mode state is client-only.
- * Required for SSR/RSC compatibility with useSyncExternalStore.
- *
- * @param instanceId - The unique identifier for the map mode instance
- * @returns A server snapshot function for useSyncExternalStore
+ * Actions for map mode
  */
-declare function getOrCreateServerSnapshot(instanceId: UniqueId): () => string;
+type MapModeActions = {
+  /** Request a mode change */
+  requestModeChange: (desiredMode: string, requestOwner: string) => void;
+};
 /**
- * Creates or retrieves a cached requestModeChange function for a given instanceId.
- * This maintains referential stability for the function reference.
- *
- * @param instanceId - The unique identifier for the map mode instance
- * @returns A requestModeChange function for this instance
+ * Map mode store
  */
-declare function getOrCreateRequestModeChange(instanceId: UniqueId): (desiredMode: string, requestOwner: string) => void;
+declare const modeStore: MapStore<MapModeState, MapModeActions>;
+/**
+ * Get the current mode for a map instance
+ */
+declare function getMode(mapId: UniqueId): string;
+/**
+ * Hook for current mode value
+ */
+declare function useMode(mapId: UniqueId): string;
 /**
  * Get the owner of the current mode for a given map instance
  * @internal - For internal map-toolkit use only
  */
 declare function getCurrentModeOwner(instanceId: UniqueId): string | undefined;
+/**
+ * Check if a given owner is registered as the owner of any mode.
+ * This includes both active mode owners and pending mode requests.
+ * @internal - For internal map-toolkit use only
+ */
+declare function isRegisteredModeOwner(instanceId: UniqueId, owner: string): boolean;
 /**
  * Manually clear map mode 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 mode instance to clear
- *
- * @example
- * ```tsx
- * // Manual cleanup (rarely needed)
- * clearMapModeState('my-map-instance');
- * ```
  */
 declare function clearMapModeState(instanceId: UniqueId): void;
 //#endregion
-export { clearMapModeState, getCurrentModeOwner, getOrCreateRequestModeChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateSubscription };
+export { clearMapModeState, getCurrentModeOwner, getMode, isRegisteredModeOwner, modeStore, useMode };
 //# sourceMappingURL=store.d.ts.map