@accelint/map-toolkit 0.5.0 → 1.0.0

package/dist/map-mode/store.js

@@ -11,68 +11,48 @@
  */
 
 
+import { createMapStore, mapClear, mapDelete, mapSet } from "../shared/create-map-store.js";
 import { MapModeEvents } from "./events.js";
 import { Broadcast } from "@accelint/bus";
 import { uuid } from "@accelint/core";
+import { getLogger } from "@accelint/logger";
 
 //#region src/map-mode/store.ts
+/**
+* Map Mode Store
+*
+* Manages mode state with ownership-based authorization.
+*
+* @example
+* ```tsx
+* import { modeStore } from '@accelint/map-toolkit/map-mode';
+*
+* function MapControls({ mapId }) {
+*   const { state, requestModeChange } = modeStore.use(mapId);
+*
+*   return (
+*     <div>
+*       <p>Current mode: {state.mode}</p>
+*       <button onClick={() => requestModeChange('draw', 'draw-layer')}>
+*         Draw Mode
+*       </button>
+*     </div>
+*   );
+* }
+* ```
+*/
+const logger = getLogger({
+	enabled: process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test",
+	level: "warn",
+	prefix: "[MapMode]",
+	pretty: true
+});
 const DEFAULT_MODE = "default";
 /**
 * Typed event bus instance for map mode events.
-* Provides type-safe event emission and listening for all map mode state changes.
 */
 const mapModeBus = Broadcast.getInstance();
 /**
-* Store for map mode state keyed by instanceId
-*/
-const modeStore = /* @__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 mode 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 mode since mode state is client-only.
-*/
-const serverSnapshotCache = /* @__PURE__ */ new Map();
-/**
-* Cache of requestModeChange functions per instanceId to maintain referential stability
-*/
-const requestModeChangeCache = /* @__PURE__ */ new Map();
-/**
-* Get or create mode state for a given instanceId
-*/
-function getOrCreateState(instanceId) {
-	if (!modeStore.has(instanceId)) modeStore.set(instanceId, {
-		mode: DEFAULT_MODE,
-		modeOwners: /* @__PURE__ */ new Map(),
-		pendingRequests: /* @__PURE__ */ new Map()
-	});
-	return modeStore.get(instanceId);
-}
-/**
-* Notify all React subscribers for a given instanceId
-*/
-function notifySubscribers(instanceId) {
-	const subscribers = componentSubscribers.get(instanceId);
-	if (subscribers) for (const onStoreChange of subscribers) onStoreChange();
-}
-/**
 * Determine if a mode change request should be auto-accepted without authorization
 */
 function shouldAutoAcceptRequest(state, desiredMode, requestOwner) {
@@ -85,27 +65,22 @@ function shouldAutoAcceptRequest(state, desiredMode, requestOwner) {
 	return false;
 }
 /**
-* Set mode and emit change event
+* Approve a request and reject all others (immutable update)
 */
-function setMode(instanceId, state, newMode) {
-	const previousMode = state.mode;
-	state.mode = newMode;
+function approveRequestAndRejectOthers(instanceId, state, approvedRequest, excludeAuthId, decisionOwner, reason, emitApproval, set) {
+	const requestsToReject = [];
+	for (const request of state.pendingRequests.values()) if (request.authId !== excludeAuthId) requestsToReject.push(request);
+	const newModeOwners = approvedRequest.desiredMode !== DEFAULT_MODE ? mapSet(state.modeOwners, approvedRequest.desiredMode, approvedRequest.requestOwner) : state.modeOwners;
+	set({
+		mode: approvedRequest.desiredMode,
+		pendingRequests: mapClear(),
+		modeOwners: newModeOwners
+	});
 	mapModeBus.emit(MapModeEvents.changed, {
-		previousMode,
-		currentMode: newMode,
+		previousMode: state.mode,
+		currentMode: approvedRequest.desiredMode,
 		id: instanceId
 	});
-	notifySubscribers(instanceId);
-}
-/**
-* Approve a request and reject all others
-*/
-function approveRequestAndRejectOthers(instanceId, state, approvedRequest, excludeAuthId, decisionOwner, reason, emitApproval) {
-	const requestsToReject = [];
-	for (const request of state.pendingRequests.values()) if (request.authId !== excludeAuthId) requestsToReject.push(request);
-	state.pendingRequests.clear();
-	setMode(instanceId, state, approvedRequest.desiredMode);
-	if (approvedRequest.desiredMode !== DEFAULT_MODE) state.modeOwners.set(approvedRequest.desiredMode, approvedRequest.requestOwner);
 	if (emitApproval) mapModeBus.emit(MapModeEvents.changeDecision, {
 		authId: approvedRequest.authId,
 		approved: true,
@@ -122,16 +97,16 @@ function approveRequestAndRejectOthers(instanceId, state, approvedRequest, exclu
 	});
 }
 /**
-* Handle pending requests when returning to default mode
+* Handle pending requests when returning to default mode (immutable update)
 */
-function handlePendingRequestsOnDefaultMode(instanceId, state, previousMode) {
+function handlePendingRequestsOnDefaultMode(instanceId, state, previousMode, set) {
 	const firstEntry = Array.from(state.pendingRequests.values())[0];
 	if (!firstEntry) return;
 	const previousModeOwner = state.modeOwners.get(previousMode);
 	if (!previousModeOwner) return;
 	if (firstEntry.desiredMode === DEFAULT_MODE) {
 		const allRequests = Array.from(state.pendingRequests.values());
-		state.pendingRequests.clear();
+		set({ pendingRequests: mapClear() });
 		for (const request of allRequests) mapModeBus.emit(MapModeEvents.changeDecision, {
 			authId: request.authId,
 			approved: false,
@@ -139,24 +114,16 @@ function handlePendingRequestsOnDefaultMode(instanceId, state, previousMode) {
 			reason: "Request rejected - already in requested mode",
 			id: instanceId
 		});
-	} else approveRequestAndRejectOthers(instanceId, state, firstEntry, firstEntry.authId, previousModeOwner, "Auto-accepted when mode owner returned to default", true);
+	} else approveRequestAndRejectOthers(instanceId, state, firstEntry, firstEntry.authId, previousModeOwner, "Auto-accepted when mode owner returned to default", true, set);
 }
 /**
-* Handle authorization decision
-*
-* Processes approval/rejection decisions from mode owners. Only the current mode's owner
-* can make authorization decisions. If a decision comes from a non-owner, a warning is
-* logged and the decision is ignored to prevent unauthorized mode changes.
-*
-* @param instanceId - The unique identifier for this map instance
-* @param state - The mode state for this instance
-* @param payload - The authorization decision containing authId, approved status, and owner
+* Handle authorization decision (immutable update)
 */
-function handleAuthorizationDecision(instanceId, state, payload) {
+function handleAuthorizationDecision(instanceId, state, payload, set) {
 	const { approved, authId, owner: decisionOwner } = payload;
 	const currentModeOwner = state.modeOwners.get(state.mode);
 	if (decisionOwner !== currentModeOwner) {
-		console.warn(`[MapMode] Authorization decision from "${decisionOwner}" ignored - not the owner of mode "${state.mode}" (owner: ${currentModeOwner || "none"})`);
+		logger.warn(`Authorization decision from "${decisionOwner}" ignored - not the owner of mode "${state.mode}" (owner: ${currentModeOwner || "none"})`);
 		return;
 	}
 	let matchingRequestOwner = null;
@@ -167,27 +134,37 @@ function handleAuthorizationDecision(instanceId, state, payload) {
 		break;
 	}
 	if (!(matchingRequest && matchingRequestOwner)) return;
-	if (approved) approveRequestAndRejectOthers(instanceId, state, matchingRequest, authId, decisionOwner, "", false);
-	else state.pendingRequests.delete(matchingRequestOwner);
+	if (approved) approveRequestAndRejectOthers(instanceId, state, matchingRequest, authId, decisionOwner, "", false, set);
+	else set({ pendingRequests: mapDelete(state.pendingRequests, matchingRequestOwner) });
 }
 /**
-* Handle mode change request logic
+* Handle mode change request logic (immutable update)
 */
-function handleModeChangeRequest(instanceId, state, desiredMode, requestOwner) {
+function handleModeChangeRequest(instanceId, state, desiredMode, requestOwner, set) {
 	const desiredModeOwner = state.modeOwners.get(desiredMode);
 	if (shouldAutoAcceptRequest(state, desiredMode, requestOwner)) {
-		setMode(instanceId, state, desiredMode);
-		if (desiredMode !== DEFAULT_MODE && !desiredModeOwner) state.modeOwners.set(desiredMode, requestOwner);
-		state.pendingRequests.delete(requestOwner);
+		const newModeOwners = desiredMode !== DEFAULT_MODE && !desiredModeOwner ? mapSet(state.modeOwners, desiredMode, requestOwner) : state.modeOwners;
+		const newPendingRequests = mapDelete(state.pendingRequests, requestOwner);
+		const previousMode = state.mode;
+		set({
+			mode: desiredMode,
+			modeOwners: newModeOwners,
+			pendingRequests: newPendingRequests
+		});
+		mapModeBus.emit(MapModeEvents.changed, {
+			previousMode,
+			currentMode: desiredMode,
+			id: instanceId
+		});
 		return;
 	}
 	const authId = uuid();
-	state.pendingRequests.set(requestOwner, {
+	set({ pendingRequests: mapSet(state.pendingRequests, requestOwner, {
 		authId,
 		desiredMode,
 		currentMode: state.mode,
 		requestOwner
-	});
+	}) });
 	mapModeBus.emit(MapModeEvents.changeAuthorization, {
 		authId,
 		desiredMode,
@@ -196,126 +173,15 @@ function handleModeChangeRequest(instanceId, state, desiredMode, requestOwner) {
 	});
 }
 /**
-* 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 mode instance
+* Map mode store
 */
-function ensureBusListener(instanceId) {
-	if (busUnsubscribers.has(instanceId)) return;
-	const state = getOrCreateState(instanceId);
-	const unsubRequest = mapModeBus.on(MapModeEvents.changeRequest, (event) => {
-		const { desiredMode, owner: requestOwner, id } = event.payload;
-		if (id !== instanceId || desiredMode === state.mode) return;
-		handleModeChangeRequest(instanceId, state, desiredMode, requestOwner);
-	});
-	const unsubDecision = mapModeBus.on(MapModeEvents.changeDecision, (event) => {
-		const { id, approved, authId, owner } = event.payload;
-		if (id !== instanceId) return;
-		handleAuthorizationDecision(instanceId, state, {
-			approved,
-			authId,
-			owner
-		});
-	});
-	const unsubChanged = mapModeBus.on(MapModeEvents.changed, (event) => {
-		const { currentMode, previousMode, id } = event.payload;
-		if (id !== instanceId) return;
-		if (currentMode === DEFAULT_MODE && state.pendingRequests.size > 0) handlePendingRequestsOnDefaultMode(instanceId, state, previousMode);
-	});
-	busUnsubscribers.set(instanceId, () => {
-		unsubRequest();
-		unsubDecision();
-		unsubChanged();
-	});
-}
-/**
-* Cleans up the bus listener if no React subscribers remain.
-*
-* @param instanceId - The unique identifier for the map mode 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);
-		}
-		modeStore.delete(instanceId);
-		componentSubscribers.delete(instanceId);
-		subscriptionCache.delete(instanceId);
-		snapshotCache.delete(instanceId);
-		serverSnapshotCache.delete(instanceId);
-		requestModeChangeCache.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 map mode state when the last subscriber unsubscribes.
-*
-* @param instanceId - The unique identifier for the map mode 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);
-		};
-	});
-	subscriptionCache.set(instanceId, subscription);
-	return subscription;
-}
-/**
-* 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
-*/
-function getOrCreateSnapshot(instanceId) {
-	const snapshot = snapshotCache.get(instanceId) ?? (() => {
-		const state = modeStore.get(instanceId);
-		if (!state) return DEFAULT_MODE;
-		return state.mode;
-	});
-	snapshotCache.set(instanceId, snapshot);
-	return snapshot;
-}
-/**
-* 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
-*/
-function getOrCreateServerSnapshot(instanceId) {
-	const serverSnapshot = serverSnapshotCache.get(instanceId) ?? (() => DEFAULT_MODE);
-	serverSnapshotCache.set(instanceId, serverSnapshot);
-	return serverSnapshot;
-}
-/**
-* 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
-*/
-function getOrCreateRequestModeChange(instanceId) {
-	const requestModeChange = requestModeChangeCache.get(instanceId) ?? ((desiredMode, requestOwner) => {
+const modeStore = createMapStore({
+	defaultState: {
+		mode: DEFAULT_MODE,
+		modeOwners: /* @__PURE__ */ new Map(),
+		pendingRequests: /* @__PURE__ */ new Map()
+	},
+	actions: (instanceId) => ({ requestModeChange: (desiredMode, requestOwner) => {
 		const trimmedDesiredMode = desiredMode.trim();
 		const trimmedRequestOwner = requestOwner.trim();
 		if (!trimmedDesiredMode) throw new Error("requestModeChange requires non-empty desiredMode");
@@ -325,9 +191,47 @@ function getOrCreateRequestModeChange(instanceId) {
 			owner: trimmedRequestOwner,
 			id: instanceId
 		});
-	});
-	requestModeChangeCache.set(instanceId, requestModeChange);
-	return requestModeChange;
+	} }),
+	bus: (instanceId, { get, set }) => {
+		const unsubRequest = mapModeBus.on(MapModeEvents.changeRequest, (event) => {
+			const { desiredMode, owner: requestOwner, id } = event.payload;
+			const state = get();
+			if (id !== instanceId || desiredMode === state.mode) return;
+			handleModeChangeRequest(instanceId, state, desiredMode, requestOwner, set);
+		});
+		const unsubDecision = mapModeBus.on(MapModeEvents.changeDecision, (event) => {
+			const { id, approved, authId, owner } = event.payload;
+			if (id !== instanceId) return;
+			handleAuthorizationDecision(instanceId, get(), {
+				approved,
+				authId,
+				owner
+			}, set);
+		});
+		const unsubChanged = mapModeBus.on(MapModeEvents.changed, (event) => {
+			const { currentMode, previousMode, id } = event.payload;
+			if (id !== instanceId) return;
+			const state = get();
+			if (currentMode === DEFAULT_MODE && state.pendingRequests.size > 0) handlePendingRequestsOnDefaultMode(instanceId, state, previousMode, set);
+		});
+		return () => {
+			unsubRequest();
+			unsubDecision();
+			unsubChanged();
+		};
+	}
+});
+/**
+* Get the current mode for a map instance
+*/
+function getMode(mapId) {
+	return modeStore.get(mapId).mode;
+}
+/**
+* Hook for current mode value
+*/
+function useMode(mapId) {
+	return modeStore.useSelector(mapId, (state) => state.mode);
 }
 /**
 * Get the owner of the current mode for a given map instance
@@ -335,36 +239,26 @@ function getOrCreateRequestModeChange(instanceId) {
 */
 function getCurrentModeOwner(instanceId) {
 	const state = modeStore.get(instanceId);
-	if (!state) return;
 	return state.modeOwners.get(state.mode);
 }
 /**
+* 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
+*/
+function isRegisteredModeOwner(instanceId, owner) {
+	const state = modeStore.get(instanceId);
+	for (const modeOwner of state.modeOwners.values()) if (modeOwner === owner) return true;
+	if (state.pendingRequests.has(owner)) return true;
+	return false;
+}
+/**
 * 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');
-* ```
 */
 function clearMapModeState(instanceId) {
-	const unsub = busUnsubscribers.get(instanceId);
-	if (unsub) {
-		unsub();
-		busUnsubscribers.delete(instanceId);
-	}
-	modeStore.delete(instanceId);
-	componentSubscribers.delete(instanceId);
-	subscriptionCache.delete(instanceId);
-	snapshotCache.delete(instanceId);
-	serverSnapshotCache.delete(instanceId);
-	requestModeChangeCache.delete(instanceId);
+	modeStore.clear(instanceId);
 }
 
 //#endregion
-export { clearMapModeState, getCurrentModeOwner, getOrCreateRequestModeChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateSubscription };
+export { clearMapModeState, getCurrentModeOwner, getMode, isRegisteredModeOwner, modeStore, useMode };
 //# sourceMappingURL=store.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"store.js","names":["requestsToReject: PendingRequest[]","matchingRequestOwner: string | null","matchingRequest: PendingRequest | null"],"sources":["../../src/map-mode/store.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\nimport { Broadcast } from '@accelint/bus';\nimport { uuid } from '@accelint/core';\nimport { MapModeEvents } from './events';\nimport type { UniqueId } from '@accelint/core';\nimport type { MapModeEventType, ModeChangeDecisionPayload } from './types';\n\nconst DEFAULT_MODE = 'default';\n\n/**\n * Typed event bus instance for map mode events.\n * Provides type-safe event emission and listening for all map mode state changes.\n */\nconst mapModeBus = Broadcast.getInstance<MapModeEventType>();\n\n/**\n * Internal type for tracking pending authorization requests.\n * @internal\n */\ntype PendingRequest = {\n  authId: string;\n  desiredMode: string;\n  currentMode: string;\n  requestOwner: string;\n};\n\n/**\n * Type representing the state for a single map mode instance\n */\ntype MapModeState = {\n  mode: string;\n  modeOwners: Map<string, string>;\n  pendingRequests: Map<string, PendingRequest>;\n};\n\n/**\n * Store for map mode state keyed by instanceId\n */\nconst modeStore = new Map<UniqueId, MapModeState>();\n\n/**\n * Track React component subscribers per instanceId (for fan-out notifications).\n * Each Set contains onStoreChange callbacks from useSyncExternalStore.\n */\nconst componentSubscribers = new Map<UniqueId, Set<() => void>>();\n\n/**\n * Cache of bus unsubscribe functions (1 per instanceId).\n * This ensures we only have one bus listener per map mode instance, regardless of\n * how many React components subscribe to it.\n */\nconst busUnsubscribers = new Map<UniqueId, () => void>();\n\ntype Subscription = (onStoreChange: () => void) => () => void;\n/**\n * Cache of subscription functions per instanceId to avoid recreating on every render\n */\nconst subscriptionCache = new Map<UniqueId, Subscription>();\n\n/**\n * Cache of snapshot functions per instanceId to maintain referential stability\n */\nconst snapshotCache = new Map<UniqueId, () => string>();\n\n/**\n * Cache of server snapshot functions per instanceId to maintain referential stability.\n * Server snapshots always return default mode since mode state is client-only.\n */\nconst serverSnapshotCache = new Map<UniqueId, () => string>();\n\n/**\n * Cache of requestModeChange functions per instanceId to maintain referential stability\n */\nconst requestModeChangeCache = new Map<\n  UniqueId,\n  (desiredMode: string, requestOwner: string) => void\n>();\n\n/**\n * Get or create mode state for a given instanceId\n */\nfunction getOrCreateState(instanceId: UniqueId): MapModeState {\n  if (!modeStore.has(instanceId)) {\n    modeStore.set(instanceId, {\n      mode: DEFAULT_MODE,\n      modeOwners: new Map(),\n      pendingRequests: new Map(),\n    });\n  }\n  // biome-ignore lint/style/noNonNullAssertion: State guaranteed to exist after has() check above\n  return modeStore.get(instanceId)!;\n}\n\n/**\n * Notify all React subscribers for a given instanceId\n */\nfunction notifySubscribers(instanceId: UniqueId): void {\n  const subscribers = componentSubscribers.get(instanceId);\n  if (subscribers) {\n    for (const onStoreChange of subscribers) {\n      onStoreChange();\n    }\n  }\n}\n\n/**\n * Determine if a mode change request should be auto-accepted without authorization\n */\nfunction shouldAutoAcceptRequest(\n  state: MapModeState,\n  desiredMode: string,\n  requestOwner: string,\n): boolean {\n  const currentModeOwner = state.modeOwners.get(state.mode);\n  const desiredModeOwner = state.modeOwners.get(desiredMode);\n\n  // Owner returning to default mode\n  if (desiredMode === DEFAULT_MODE && requestOwner === currentModeOwner) {\n    return true;\n  }\n\n  // Owner switching between their own modes\n  if (requestOwner === currentModeOwner) {\n    return true;\n  }\n\n  // No ownership conflicts exist\n  if (!(currentModeOwner || desiredModeOwner)) {\n    return true;\n  }\n\n  // Entering an owned mode from default mode\n  if (state.mode === DEFAULT_MODE && requestOwner === desiredModeOwner) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Set mode and emit change event\n */\nfunction setMode(\n  instanceId: UniqueId,\n  state: MapModeState,\n  newMode: string,\n): void {\n  const previousMode = state.mode;\n  state.mode = newMode;\n\n  mapModeBus.emit(MapModeEvents.changed, {\n    previousMode,\n    currentMode: newMode,\n    id: instanceId,\n  });\n\n  notifySubscribers(instanceId);\n}\n\n/**\n * Approve a request and reject all others\n */\nfunction approveRequestAndRejectOthers(\n  instanceId: UniqueId,\n  state: MapModeState,\n  approvedRequest: PendingRequest,\n  excludeAuthId: string,\n  decisionOwner: string,\n  reason: string,\n  emitApproval: boolean,\n): void {\n  // Collect all other pending requests to emit rejections for\n  const requestsToReject: PendingRequest[] = [];\n  for (const request of state.pendingRequests.values()) {\n    if (request.authId !== excludeAuthId) {\n      requestsToReject.push(request);\n    }\n  }\n\n  // Clear all pending requests BEFORE changing mode\n  state.pendingRequests.clear();\n\n  // Change mode\n  setMode(instanceId, state, approvedRequest.desiredMode);\n\n  // Store the new mode's owner (unless it's default mode)\n  if (approvedRequest.desiredMode !== DEFAULT_MODE) {\n    state.modeOwners.set(\n      approvedRequest.desiredMode,\n      approvedRequest.requestOwner,\n    );\n  }\n\n  // Emit approval decision if requested\n  if (emitApproval) {\n    mapModeBus.emit(MapModeEvents.changeDecision, {\n      authId: approvedRequest.authId,\n      approved: true,\n      owner: decisionOwner,\n      reason,\n      id: instanceId,\n    });\n  }\n\n  // Emit rejection events for all other pending requests\n  for (const request of requestsToReject) {\n    mapModeBus.emit(MapModeEvents.changeDecision, {\n      authId: request.authId,\n      approved: false,\n      owner: decisionOwner,\n      reason: 'Request auto-rejected because another request was approved',\n      id: instanceId,\n    });\n  }\n}\n\n/**\n * Handle pending requests when returning to default mode\n */\nfunction handlePendingRequestsOnDefaultMode(\n  instanceId: UniqueId,\n  state: MapModeState,\n  previousMode: string,\n): void {\n  const firstEntry = Array.from(state.pendingRequests.values())[0];\n  if (!firstEntry) {\n    return;\n  }\n\n  const previousModeOwner = state.modeOwners.get(previousMode);\n\n  if (!previousModeOwner) {\n    return;\n  }\n\n  // If the first pending request is for default mode, reject all requests\n  if (firstEntry.desiredMode === DEFAULT_MODE) {\n    const allRequests = Array.from(state.pendingRequests.values());\n    state.pendingRequests.clear();\n\n    for (const request of allRequests) {\n      mapModeBus.emit(MapModeEvents.changeDecision, {\n        authId: request.authId,\n        approved: false,\n        owner: previousModeOwner,\n        reason: 'Request rejected - already in requested mode',\n        id: instanceId,\n      } satisfies ModeChangeDecisionPayload);\n    }\n  } else {\n    // Auto-accept the first pending request for a different mode\n    approveRequestAndRejectOthers(\n      instanceId,\n      state,\n      firstEntry,\n      firstEntry.authId,\n      previousModeOwner,\n      'Auto-accepted when mode owner returned to default',\n      true,\n    );\n  }\n}\n\n/**\n * Handle authorization decision\n *\n * Processes approval/rejection decisions from mode owners. Only the current mode's owner\n * can make authorization decisions. If a decision comes from a non-owner, a warning is\n * logged and the decision is ignored to prevent unauthorized mode changes.\n *\n * @param instanceId - The unique identifier for this map instance\n * @param state - The mode state for this instance\n * @param payload - The authorization decision containing authId, approved status, and owner\n */\nfunction handleAuthorizationDecision(\n  instanceId: UniqueId,\n  state: MapModeState,\n  payload: {\n    approved: boolean;\n    authId: string;\n    owner: string;\n  },\n): void {\n  const { approved, authId, owner: decisionOwner } = payload;\n\n  // Verify decision is from current mode's owner\n  // Logs a warning if unauthorized component attempts to make decisions\n  const currentModeOwner = state.modeOwners.get(state.mode);\n  if (decisionOwner !== currentModeOwner) {\n    console.warn(\n      `[MapMode] Authorization decision from \"${decisionOwner}\" ignored - not the owner of mode \"${state.mode}\" (owner: ${currentModeOwner || 'none'})`,\n    );\n    return;\n  }\n\n  // Find the request with matching authId\n  let matchingRequestOwner: string | null = null;\n  let matchingRequest: PendingRequest | null = null;\n\n  for (const [requestOwner, request] of state.pendingRequests.entries()) {\n    if (request.authId === authId) {\n      matchingRequestOwner = requestOwner;\n      matchingRequest = request;\n      break;\n    }\n  }\n\n  if (!(matchingRequest && matchingRequestOwner)) {\n    return;\n  }\n\n  if (approved) {\n    approveRequestAndRejectOthers(\n      instanceId,\n      state,\n      matchingRequest,\n      authId,\n      decisionOwner,\n      '',\n      false,\n    );\n  } else {\n    state.pendingRequests.delete(matchingRequestOwner);\n  }\n}\n\n/**\n * Handle mode change request logic\n */\nfunction handleModeChangeRequest(\n  instanceId: UniqueId,\n  state: MapModeState,\n  desiredMode: string,\n  requestOwner: string,\n): void {\n  const desiredModeOwner = state.modeOwners.get(desiredMode);\n\n  // Check if this request should be auto-accepted\n  if (shouldAutoAcceptRequest(state, desiredMode, requestOwner)) {\n    setMode(instanceId, state, desiredMode);\n\n    // Store the desired mode's owner unless it's default\n    if (desiredMode !== DEFAULT_MODE && !desiredModeOwner) {\n      state.modeOwners.set(desiredMode, requestOwner);\n    }\n\n    // Clear requester's pending request since mode changed successfully\n    state.pendingRequests.delete(requestOwner);\n    return;\n  }\n\n  // Otherwise, send authorization request\n  const authId = uuid();\n\n  state.pendingRequests.set(requestOwner, {\n    authId,\n    desiredMode,\n    currentMode: state.mode,\n    requestOwner,\n  });\n\n  mapModeBus.emit(MapModeEvents.changeAuthorization, {\n    authId,\n    desiredMode,\n    currentMode: state.mode,\n    id: instanceId,\n  });\n}\n\n/**\n * Ensures a single bus listener exists for the given instanceId.\n * All React subscribers will be notified via fan-out when the bus events fire.\n * This prevents creating N bus listeners for N React components.\n *\n * @param instanceId - The unique identifier for the map mode instance\n */\nfunction ensureBusListener(instanceId: UniqueId): void {\n  if (busUnsubscribers.has(instanceId)) {\n    return; // Already listening\n  }\n\n  const state = getOrCreateState(instanceId);\n\n  // Listen for mode change requests\n  const unsubRequest = mapModeBus.on(MapModeEvents.changeRequest, (event) => {\n    const { desiredMode, owner: requestOwner, id } = event.payload;\n\n    // Filter: only handle if targeted at this map\n    if (id !== instanceId || desiredMode === state.mode) {\n      return;\n    }\n\n    handleModeChangeRequest(instanceId, state, desiredMode, requestOwner);\n  });\n\n  // Listen for authorization decisions\n  const unsubDecision = mapModeBus.on(MapModeEvents.changeDecision, (event) => {\n    const { id, approved, authId, owner } = event.payload;\n\n    // Filter: only handle if targeted at this map\n    if (id !== instanceId) {\n      return;\n    }\n\n    handleAuthorizationDecision(instanceId, state, { approved, authId, owner });\n  });\n\n  // Listen for mode changes to handle pending requests\n  const unsubChanged = mapModeBus.on(MapModeEvents.changed, (event) => {\n    const { currentMode, previousMode, id } = event.payload;\n\n    // Filter: only handle if targeted at this map\n    if (id !== instanceId) {\n      return;\n    }\n\n    // When mode owner changes to default mode, handle pending requests\n    if (currentMode === DEFAULT_MODE && state.pendingRequests.size > 0) {\n      handlePendingRequestsOnDefaultMode(instanceId, state, previousMode);\n    }\n  });\n\n  // Store composite cleanup function\n  busUnsubscribers.set(instanceId, () => {\n    unsubRequest();\n    unsubDecision();\n    unsubChanged();\n  });\n}\n\n/**\n * Cleans up the bus listener if no React subscribers remain.\n *\n * @param instanceId - The unique identifier for the map mode instance\n */\nfunction cleanupBusListenerIfNeeded(instanceId: UniqueId): void {\n  const subscribers = componentSubscribers.get(instanceId);\n\n  if (!subscribers || subscribers.size === 0) {\n    // No more React subscribers - clean up bus listener\n    const unsub = busUnsubscribers.get(instanceId);\n    if (unsub) {\n      unsub();\n      busUnsubscribers.delete(instanceId);\n    }\n\n    // Clean up all state\n    modeStore.delete(instanceId);\n    componentSubscribers.delete(instanceId);\n    subscriptionCache.delete(instanceId);\n    snapshotCache.delete(instanceId);\n    serverSnapshotCache.delete(instanceId);\n    requestModeChangeCache.delete(instanceId);\n  }\n}\n\n/**\n * Creates or retrieves a cached subscription function for a given instanceId.\n * Uses a fan-out pattern: 1 bus listener -> N React subscribers.\n * Automatically cleans up map mode state when the last subscriber unsubscribes.\n *\n * @param instanceId - The unique identifier for the map mode instance\n * @returns A subscription function for useSyncExternalStore\n */\nexport function getOrCreateSubscription(\n  instanceId: UniqueId,\n): (onStoreChange: () => void) => () => void {\n  const subscription =\n    subscriptionCache.get(instanceId) ??\n    ((onStoreChange: () => void) => {\n      // Ensure state exists\n      getOrCreateState(instanceId);\n\n      // Ensure single bus listener exists for this instanceId\n      ensureBusListener(instanceId);\n\n      // Get or create the subscriber set for this map instance, then add this component's callback\n      let subscriberSet = componentSubscribers.get(instanceId);\n      if (!subscriberSet) {\n        subscriberSet = new Set();\n        componentSubscribers.set(instanceId, subscriberSet);\n      }\n      subscriberSet.add(onStoreChange);\n\n      // Return cleanup function to remove this component's subscription\n      return () => {\n        const currentSubscriberSet = componentSubscribers.get(instanceId);\n        if (currentSubscriberSet) {\n          currentSubscriberSet.delete(onStoreChange);\n        }\n\n        // Clean up bus listener if this was the last React subscriber\n        cleanupBusListenerIfNeeded(instanceId);\n      };\n    });\n\n  subscriptionCache.set(instanceId, subscription);\n\n  return subscription;\n}\n\n/**\n * Creates or retrieves a cached snapshot function for a given instanceId.\n * The string returned gets equality checked, so it needs to be stable or React re-renders unnecessarily.\n *\n * @param instanceId - The unique identifier for the map mode instance\n * @returns A snapshot function for useSyncExternalStore\n */\nexport function getOrCreateSnapshot(instanceId: UniqueId): () => string {\n  const snapshot =\n    snapshotCache.get(instanceId) ??\n    (() => {\n      const state = modeStore.get(instanceId);\n      if (!state) {\n        return DEFAULT_MODE;\n      }\n      return state.mode;\n    });\n\n  snapshotCache.set(instanceId, snapshot);\n\n  return snapshot;\n}\n\n/**\n * Creates or retrieves a cached server snapshot function for a given instanceId.\n * Server snapshots always return the default mode since mode state is client-only.\n * Required for SSR/RSC compatibility with useSyncExternalStore.\n *\n * @param instanceId - The unique identifier for the map mode instance\n * @returns A server snapshot function for useSyncExternalStore\n */\nexport function getOrCreateServerSnapshot(instanceId: UniqueId): () => string {\n  const serverSnapshot =\n    serverSnapshotCache.get(instanceId) ?? (() => DEFAULT_MODE);\n\n  serverSnapshotCache.set(instanceId, serverSnapshot);\n\n  return serverSnapshot;\n}\n\n/**\n * Creates or retrieves a cached requestModeChange function for a given instanceId.\n * This maintains referential stability for the function reference.\n *\n * @param instanceId - The unique identifier for the map mode instance\n * @returns A requestModeChange function for this instance\n */\nexport function getOrCreateRequestModeChange(\n  instanceId: UniqueId,\n): (desiredMode: string, requestOwner: string) => void {\n  const requestModeChange =\n    requestModeChangeCache.get(instanceId) ??\n    ((desiredMode: string, requestOwner: string) => {\n      const trimmedDesiredMode = desiredMode.trim();\n      const trimmedRequestOwner = requestOwner.trim();\n\n      if (!trimmedDesiredMode) {\n        throw new Error('requestModeChange requires non-empty desiredMode');\n      }\n      if (!trimmedRequestOwner) {\n        throw new Error('requestModeChange requires non-empty requestOwner');\n      }\n\n      mapModeBus.emit(MapModeEvents.changeRequest, {\n        desiredMode: trimmedDesiredMode,\n        owner: trimmedRequestOwner,\n        id: instanceId,\n      });\n    });\n\n  requestModeChangeCache.set(instanceId, requestModeChange);\n\n  return requestModeChange;\n}\n\n/**\n * Get the owner of the current mode for a given map instance\n * @internal - For internal map-toolkit use only\n */\nexport function getCurrentModeOwner(instanceId: UniqueId): string | undefined {\n  const state = modeStore.get(instanceId);\n  if (!state) {\n    return undefined;\n  }\n  return state.modeOwners.get(state.mode);\n}\n\n/**\n * Manually clear map mode state for a specific instanceId.\n * This is typically not needed as cleanup happens automatically when all subscribers unmount.\n * Use this only in advanced scenarios where manual cleanup is required.\n *\n * @param instanceId - The unique identifier for the map mode instance to clear\n *\n * @example\n * ```tsx\n * // Manual cleanup (rarely needed)\n * clearMapModeState('my-map-instance');\n * ```\n */\nexport function clearMapModeState(instanceId: UniqueId): void {\n  // Unsubscribe from bus if listening\n  const unsub = busUnsubscribers.get(instanceId);\n  if (unsub) {\n    unsub();\n    busUnsubscribers.delete(instanceId);\n  }\n\n  // Clear all state\n  modeStore.delete(instanceId);\n  componentSubscribers.delete(instanceId);\n  subscriptionCache.delete(instanceId);\n  snapshotCache.delete(instanceId);\n  serverSnapshotCache.delete(instanceId);\n  requestModeChangeCache.delete(instanceId);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,MAAM,eAAe;;;;;AAMrB,MAAM,aAAa,UAAU,aAA+B;;;;AAyB5D,MAAM,4BAAY,IAAI,KAA6B;;;;;AAMnD,MAAM,uCAAuB,IAAI,KAAgC;;;;;;AAOjE,MAAM,mCAAmB,IAAI,KAA2B;;;;AAMxD,MAAM,oCAAoB,IAAI,KAA6B;;;;AAK3D,MAAM,gCAAgB,IAAI,KAA6B;;;;;AAMvD,MAAM,sCAAsB,IAAI,KAA6B;;;;AAK7D,MAAM,yCAAyB,IAAI,KAGhC;;;;AAKH,SAAS,iBAAiB,YAAoC;AAC5D,KAAI,CAAC,UAAU,IAAI,WAAW,CAC5B,WAAU,IAAI,YAAY;EACxB,MAAM;EACN,4BAAY,IAAI,KAAK;EACrB,iCAAiB,IAAI,KAAK;EAC3B,CAAC;AAGJ,QAAO,UAAU,IAAI,WAAW;;;;;AAMlC,SAAS,kBAAkB,YAA4B;CACrD,MAAM,cAAc,qBAAqB,IAAI,WAAW;AACxD,KAAI,YACF,MAAK,MAAM,iBAAiB,YAC1B,gBAAe;;;;;AAQrB,SAAS,wBACP,OACA,aACA,cACS;CACT,MAAM,mBAAmB,MAAM,WAAW,IAAI,MAAM,KAAK;CACzD,MAAM,mBAAmB,MAAM,WAAW,IAAI,YAAY;AAG1D,KAAI,gBAAgB,gBAAgB,iBAAiB,iBACnD,QAAO;AAIT,KAAI,iBAAiB,iBACnB,QAAO;AAIT,KAAI,EAAE,oBAAoB,kBACxB,QAAO;AAIT,KAAI,MAAM,SAAS,gBAAgB,iBAAiB,iBAClD,QAAO;AAGT,QAAO;;;;;AAMT,SAAS,QACP,YACA,OACA,SACM;CACN,MAAM,eAAe,MAAM;AAC3B,OAAM,OAAO;AAEb,YAAW,KAAK,cAAc,SAAS;EACrC;EACA,aAAa;EACb,IAAI;EACL,CAAC;AAEF,mBAAkB,WAAW;;;;;AAM/B,SAAS,8BACP,YACA,OACA,iBACA,eACA,eACA,QACA,cACM;CAEN,MAAMA,mBAAqC,EAAE;AAC7C,MAAK,MAAM,WAAW,MAAM,gBAAgB,QAAQ,CAClD,KAAI,QAAQ,WAAW,cACrB,kBAAiB,KAAK,QAAQ;AAKlC,OAAM,gBAAgB,OAAO;AAG7B,SAAQ,YAAY,OAAO,gBAAgB,YAAY;AAGvD,KAAI,gBAAgB,gBAAgB,aAClC,OAAM,WAAW,IACf,gBAAgB,aAChB,gBAAgB,aACjB;AAIH,KAAI,aACF,YAAW,KAAK,cAAc,gBAAgB;EAC5C,QAAQ,gBAAgB;EACxB,UAAU;EACV,OAAO;EACP;EACA,IAAI;EACL,CAAC;AAIJ,MAAK,MAAM,WAAW,iBACpB,YAAW,KAAK,cAAc,gBAAgB;EAC5C,QAAQ,QAAQ;EAChB,UAAU;EACV,OAAO;EACP,QAAQ;EACR,IAAI;EACL,CAAC;;;;;AAON,SAAS,mCACP,YACA,OACA,cACM;CACN,MAAM,aAAa,MAAM,KAAK,MAAM,gBAAgB,QAAQ,CAAC,CAAC;AAC9D,KAAI,CAAC,WACH;CAGF,MAAM,oBAAoB,MAAM,WAAW,IAAI,aAAa;AAE5D,KAAI,CAAC,kBACH;AAIF,KAAI,WAAW,gBAAgB,cAAc;EAC3C,MAAM,cAAc,MAAM,KAAK,MAAM,gBAAgB,QAAQ,CAAC;AAC9D,QAAM,gBAAgB,OAAO;AAE7B,OAAK,MAAM,WAAW,YACpB,YAAW,KAAK,cAAc,gBAAgB;GAC5C,QAAQ,QAAQ;GAChB,UAAU;GACV,OAAO;GACP,QAAQ;GACR,IAAI;GACL,CAAqC;OAIxC,+BACE,YACA,OACA,YACA,WAAW,QACX,mBACA,qDACA,KACD;;;;;;;;;;;;;AAeL,SAAS,4BACP,YACA,OACA,SAKM;CACN,MAAM,EAAE,UAAU,QAAQ,OAAO,kBAAkB;CAInD,MAAM,mBAAmB,MAAM,WAAW,IAAI,MAAM,KAAK;AACzD,KAAI,kBAAkB,kBAAkB;AACtC,UAAQ,KACN,0CAA0C,cAAc,qCAAqC,MAAM,KAAK,YAAY,oBAAoB,OAAO,GAChJ;AACD;;CAIF,IAAIC,uBAAsC;CAC1C,IAAIC,kBAAyC;AAE7C,MAAK,MAAM,CAAC,cAAc,YAAY,MAAM,gBAAgB,SAAS,CACnE,KAAI,QAAQ,WAAW,QAAQ;AAC7B,yBAAuB;AACvB,oBAAkB;AAClB;;AAIJ,KAAI,EAAE,mBAAmB,sBACvB;AAGF,KAAI,SACF,+BACE,YACA,OACA,iBACA,QACA,eACA,IACA,MACD;KAED,OAAM,gBAAgB,OAAO,qBAAqB;;;;;AAOtD,SAAS,wBACP,YACA,OACA,aACA,cACM;CACN,MAAM,mBAAmB,MAAM,WAAW,IAAI,YAAY;AAG1D,KAAI,wBAAwB,OAAO,aAAa,aAAa,EAAE;AAC7D,UAAQ,YAAY,OAAO,YAAY;AAGvC,MAAI,gBAAgB,gBAAgB,CAAC,iBACnC,OAAM,WAAW,IAAI,aAAa,aAAa;AAIjD,QAAM,gBAAgB,OAAO,aAAa;AAC1C;;CAIF,MAAM,SAAS,MAAM;AAErB,OAAM,gBAAgB,IAAI,cAAc;EACtC;EACA;EACA,aAAa,MAAM;EACnB;EACD,CAAC;AAEF,YAAW,KAAK,cAAc,qBAAqB;EACjD;EACA;EACA,aAAa,MAAM;EACnB,IAAI;EACL,CAAC;;;;;;;;;AAUJ,SAAS,kBAAkB,YAA4B;AACrD,KAAI,iBAAiB,IAAI,WAAW,CAClC;CAGF,MAAM,QAAQ,iBAAiB,WAAW;CAG1C,MAAM,eAAe,WAAW,GAAG,cAAc,gBAAgB,UAAU;EACzE,MAAM,EAAE,aAAa,OAAO,cAAc,OAAO,MAAM;AAGvD,MAAI,OAAO,cAAc,gBAAgB,MAAM,KAC7C;AAGF,0BAAwB,YAAY,OAAO,aAAa,aAAa;GACrE;CAGF,MAAM,gBAAgB,WAAW,GAAG,cAAc,iBAAiB,UAAU;EAC3E,MAAM,EAAE,IAAI,UAAU,QAAQ,UAAU,MAAM;AAG9C,MAAI,OAAO,WACT;AAGF,8BAA4B,YAAY,OAAO;GAAE;GAAU;GAAQ;GAAO,CAAC;GAC3E;CAGF,MAAM,eAAe,WAAW,GAAG,cAAc,UAAU,UAAU;EACnE,MAAM,EAAE,aAAa,cAAc,OAAO,MAAM;AAGhD,MAAI,OAAO,WACT;AAIF,MAAI,gBAAgB,gBAAgB,MAAM,gBAAgB,OAAO,EAC/D,oCAAmC,YAAY,OAAO,aAAa;GAErE;AAGF,kBAAiB,IAAI,kBAAkB;AACrC,gBAAc;AACd,iBAAe;AACf,gBAAc;GACd;;;;;;;AAQJ,SAAS,2BAA2B,YAA4B;CAC9D,MAAM,cAAc,qBAAqB,IAAI,WAAW;AAExD,KAAI,CAAC,eAAe,YAAY,SAAS,GAAG;EAE1C,MAAM,QAAQ,iBAAiB,IAAI,WAAW;AAC9C,MAAI,OAAO;AACT,UAAO;AACP,oBAAiB,OAAO,WAAW;;AAIrC,YAAU,OAAO,WAAW;AAC5B,uBAAqB,OAAO,WAAW;AACvC,oBAAkB,OAAO,WAAW;AACpC,gBAAc,OAAO,WAAW;AAChC,sBAAoB,OAAO,WAAW;AACtC,yBAAuB,OAAO,WAAW;;;;;;;;;;;AAY7C,SAAgB,wBACd,YAC2C;CAC3C,MAAM,eACJ,kBAAkB,IAAI,WAAW,MAC/B,kBAA8B;AAE9B,mBAAiB,WAAW;AAG5B,oBAAkB,WAAW;EAG7B,IAAI,gBAAgB,qBAAqB,IAAI,WAAW;AACxD,MAAI,CAAC,eAAe;AAClB,mCAAgB,IAAI,KAAK;AACzB,wBAAqB,IAAI,YAAY,cAAc;;AAErD,gBAAc,IAAI,cAAc;AAGhC,eAAa;GACX,MAAM,uBAAuB,qBAAqB,IAAI,WAAW;AACjE,OAAI,qBACF,sBAAqB,OAAO,cAAc;AAI5C,8BAA2B,WAAW;;;AAI5C,mBAAkB,IAAI,YAAY,aAAa;AAE/C,QAAO;;;;;;;;;AAUT,SAAgB,oBAAoB,YAAoC;CACtE,MAAM,WACJ,cAAc,IAAI,WAAW,WACtB;EACL,MAAM,QAAQ,UAAU,IAAI,WAAW;AACvC,MAAI,CAAC,MACH,QAAO;AAET,SAAO,MAAM;;AAGjB,eAAc,IAAI,YAAY,SAAS;AAEvC,QAAO;;;;;;;;;;AAWT,SAAgB,0BAA0B,YAAoC;CAC5E,MAAM,iBACJ,oBAAoB,IAAI,WAAW,WAAW;AAEhD,qBAAoB,IAAI,YAAY,eAAe;AAEnD,QAAO;;;;;;;;;AAUT,SAAgB,6BACd,YACqD;CACrD,MAAM,oBACJ,uBAAuB,IAAI,WAAW,MACpC,aAAqB,iBAAyB;EAC9C,MAAM,qBAAqB,YAAY,MAAM;EAC7C,MAAM,sBAAsB,aAAa,MAAM;AAE/C,MAAI,CAAC,mBACH,OAAM,IAAI,MAAM,mDAAmD;AAErE,MAAI,CAAC,oBACH,OAAM,IAAI,MAAM,oDAAoD;AAGtE,aAAW,KAAK,cAAc,eAAe;GAC3C,aAAa;GACb,OAAO;GACP,IAAI;GACL,CAAC;;AAGN,wBAAuB,IAAI,YAAY,kBAAkB;AAEzD,QAAO;;;;;;AAOT,SAAgB,oBAAoB,YAA0C;CAC5E,MAAM,QAAQ,UAAU,IAAI,WAAW;AACvC,KAAI,CAAC,MACH;AAEF,QAAO,MAAM,WAAW,IAAI,MAAM,KAAK;;;;;;;;;;;;;;;AAgBzC,SAAgB,kBAAkB,YAA4B;CAE5D,MAAM,QAAQ,iBAAiB,IAAI,WAAW;AAC9C,KAAI,OAAO;AACT,SAAO;AACP,mBAAiB,OAAO,WAAW;;AAIrC,WAAU,OAAO,WAAW;AAC5B,sBAAqB,OAAO,WAAW;AACvC,mBAAkB,OAAO,WAAW;AACpC,eAAc,OAAO,WAAW;AAChC,qBAAoB,OAAO,WAAW;AACtC,wBAAuB,OAAO,WAAW"}
+{"version":3,"file":"store.js","names":["requestsToReject: PendingRequest[]","matchingRequestOwner: string | null","matchingRequest: PendingRequest | null"],"sources":["../../src/map-mode/store.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 * Map Mode Store\n *\n * Manages mode state with ownership-based authorization.\n *\n * @example\n * ```tsx\n * import { modeStore } from '@accelint/map-toolkit/map-mode';\n *\n * function MapControls({ mapId }) {\n *   const { state, requestModeChange } = modeStore.use(mapId);\n *\n *   return (\n *     <div>\n *       <p>Current mode: {state.mode}</p>\n *       <button onClick={() => requestModeChange('draw', 'draw-layer')}>\n *         Draw Mode\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n */\n\nimport { Broadcast } from '@accelint/bus';\nimport { uuid } from '@accelint/core';\nimport { getLogger } from '@accelint/logger';\nimport {\n  createMapStore,\n  mapClear,\n  mapDelete,\n  mapSet,\n} from '../shared/create-map-store';\nimport { MapModeEvents } from './events';\nimport type { UniqueId } from '@accelint/core';\nimport type { StoreHelpers } from '../shared/create-map-store';\nimport type { MapModeEventType, ModeChangeDecisionPayload } from './types';\n\nconst logger = getLogger({\n  enabled:\n    process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test',\n  level: 'warn',\n  prefix: '[MapMode]',\n  pretty: true,\n});\n\nconst DEFAULT_MODE = 'default';\n\n/**\n * Typed event bus instance for map mode events.\n */\nconst mapModeBus = Broadcast.getInstance<MapModeEventType>();\n\n/**\n * Internal type for tracking pending authorization requests.\n */\ntype PendingRequest = {\n  authId: string;\n  desiredMode: string;\n  currentMode: string;\n  requestOwner: string;\n};\n\n/**\n * State shape for map mode\n */\ntype MapModeState = {\n  mode: string;\n  modeOwners: Map<string, string>;\n  pendingRequests: Map<string, PendingRequest>;\n};\n\n/**\n * Actions for map mode\n */\ntype MapModeActions = {\n  /** Request a mode change */\n  requestModeChange: (desiredMode: string, requestOwner: string) => void;\n};\n\n/**\n * Determine if a mode change request should be auto-accepted without authorization\n */\nfunction shouldAutoAcceptRequest(\n  state: MapModeState,\n  desiredMode: string,\n  requestOwner: string,\n): boolean {\n  const currentModeOwner = state.modeOwners.get(state.mode);\n  const desiredModeOwner = state.modeOwners.get(desiredMode);\n\n  // Owner returning to default mode\n  if (desiredMode === DEFAULT_MODE && requestOwner === currentModeOwner) {\n    return true;\n  }\n\n  // Owner switching between their own modes\n  if (requestOwner === currentModeOwner) {\n    return true;\n  }\n\n  // No ownership conflicts exist\n  if (!(currentModeOwner || desiredModeOwner)) {\n    return true;\n  }\n\n  // Entering an owned mode from default mode\n  if (state.mode === DEFAULT_MODE && requestOwner === desiredModeOwner) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Approve a request and reject all others (immutable update)\n */\nfunction approveRequestAndRejectOthers(\n  instanceId: UniqueId,\n  state: MapModeState,\n  approvedRequest: PendingRequest,\n  excludeAuthId: string,\n  decisionOwner: string,\n  reason: string,\n  emitApproval: boolean,\n  set: StoreHelpers<MapModeState>['set'],\n): void {\n  // Collect all other pending requests to emit rejections for\n  const requestsToReject: PendingRequest[] = [];\n  for (const request of state.pendingRequests.values()) {\n    if (request.authId !== excludeAuthId) {\n      requestsToReject.push(request);\n    }\n  }\n\n  // Build immutable updates: clear pending requests, update owners\n  const newModeOwners =\n    approvedRequest.desiredMode !== DEFAULT_MODE\n      ? mapSet(\n          state.modeOwners,\n          approvedRequest.desiredMode,\n          approvedRequest.requestOwner,\n        )\n      : state.modeOwners;\n\n  // Immutable update: clear pending requests, update owners, change mode\n  set({\n    mode: approvedRequest.desiredMode,\n    pendingRequests: mapClear<string, PendingRequest>(),\n    modeOwners: newModeOwners,\n  });\n\n  // Emit mode changed event\n  mapModeBus.emit(MapModeEvents.changed, {\n    previousMode: state.mode,\n    currentMode: approvedRequest.desiredMode,\n    id: instanceId,\n  });\n\n  // Emit approval decision if requested\n  if (emitApproval) {\n    mapModeBus.emit(MapModeEvents.changeDecision, {\n      authId: approvedRequest.authId,\n      approved: true,\n      owner: decisionOwner,\n      reason,\n      id: instanceId,\n    });\n  }\n\n  // Emit rejection events for all other pending requests\n  for (const request of requestsToReject) {\n    mapModeBus.emit(MapModeEvents.changeDecision, {\n      authId: request.authId,\n      approved: false,\n      owner: decisionOwner,\n      reason: 'Request auto-rejected because another request was approved',\n      id: instanceId,\n    });\n  }\n}\n\n/**\n * Handle pending requests when returning to default mode (immutable update)\n */\nfunction handlePendingRequestsOnDefaultMode(\n  instanceId: UniqueId,\n  state: MapModeState,\n  previousMode: string,\n  set: StoreHelpers<MapModeState>['set'],\n): void {\n  const firstEntry = Array.from(state.pendingRequests.values())[0];\n  if (!firstEntry) {\n    return;\n  }\n\n  const previousModeOwner = state.modeOwners.get(previousMode);\n\n  if (!previousModeOwner) {\n    return;\n  }\n\n  // If the first pending request is for default mode, reject all requests\n  if (firstEntry.desiredMode === DEFAULT_MODE) {\n    const allRequests = Array.from(state.pendingRequests.values());\n\n    // Immutable update: clear pending requests\n    set({ pendingRequests: mapClear<string, PendingRequest>() });\n\n    for (const request of allRequests) {\n      mapModeBus.emit(MapModeEvents.changeDecision, {\n        authId: request.authId,\n        approved: false,\n        owner: previousModeOwner,\n        reason: 'Request rejected - already in requested mode',\n        id: instanceId,\n      } satisfies ModeChangeDecisionPayload);\n    }\n  } else {\n    // Auto-accept the first pending request for a different mode\n    approveRequestAndRejectOthers(\n      instanceId,\n      state,\n      firstEntry,\n      firstEntry.authId,\n      previousModeOwner,\n      'Auto-accepted when mode owner returned to default',\n      true,\n      set,\n    );\n  }\n}\n\n/**\n * Handle authorization decision (immutable update)\n */\nfunction handleAuthorizationDecision(\n  instanceId: UniqueId,\n  state: MapModeState,\n  payload: {\n    approved: boolean;\n    authId: string;\n    owner: string;\n  },\n  set: StoreHelpers<MapModeState>['set'],\n): void {\n  const { approved, authId, owner: decisionOwner } = payload;\n\n  // Verify decision is from current mode's owner\n  const currentModeOwner = state.modeOwners.get(state.mode);\n  if (decisionOwner !== currentModeOwner) {\n    logger.warn(\n      `Authorization decision from \"${decisionOwner}\" ignored - not the owner of mode \"${state.mode}\" (owner: ${currentModeOwner || 'none'})`,\n    );\n    return;\n  }\n\n  // Find the request with matching authId\n  let matchingRequestOwner: string | null = null;\n  let matchingRequest: PendingRequest | null = null;\n\n  for (const [requestOwner, request] of state.pendingRequests.entries()) {\n    if (request.authId === authId) {\n      matchingRequestOwner = requestOwner;\n      matchingRequest = request;\n      break;\n    }\n  }\n\n  if (!(matchingRequest && matchingRequestOwner)) {\n    return;\n  }\n\n  if (approved) {\n    approveRequestAndRejectOthers(\n      instanceId,\n      state,\n      matchingRequest,\n      authId,\n      decisionOwner,\n      '',\n      false,\n      set,\n    );\n  } else {\n    // Immutable update: remove the rejected request\n    set({\n      pendingRequests: mapDelete(state.pendingRequests, matchingRequestOwner),\n    });\n  }\n}\n\n/**\n * Handle mode change request logic (immutable update)\n */\nfunction handleModeChangeRequest(\n  instanceId: UniqueId,\n  state: MapModeState,\n  desiredMode: string,\n  requestOwner: string,\n  set: StoreHelpers<MapModeState>['set'],\n): void {\n  const desiredModeOwner = state.modeOwners.get(desiredMode);\n\n  // Check if this request should be auto-accepted\n  if (shouldAutoAcceptRequest(state, desiredMode, requestOwner)) {\n    // Build immutable updates\n    const newModeOwners =\n      desiredMode !== DEFAULT_MODE && !desiredModeOwner\n        ? mapSet(state.modeOwners, desiredMode, requestOwner)\n        : state.modeOwners;\n\n    // Clear requester's pending request since mode changed successfully\n    const newPendingRequests = mapDelete(state.pendingRequests, requestOwner);\n\n    const previousMode = state.mode;\n\n    // Immutable update\n    set({\n      mode: desiredMode,\n      modeOwners: newModeOwners,\n      pendingRequests: newPendingRequests,\n    });\n\n    mapModeBus.emit(MapModeEvents.changed, {\n      previousMode,\n      currentMode: desiredMode,\n      id: instanceId,\n    });\n\n    return;\n  }\n\n  // Otherwise, send authorization request\n  const authId = uuid();\n\n  // Immutable update: add pending request\n  set({\n    pendingRequests: mapSet(state.pendingRequests, requestOwner, {\n      authId,\n      desiredMode,\n      currentMode: state.mode,\n      requestOwner,\n    }),\n  });\n\n  mapModeBus.emit(MapModeEvents.changeAuthorization, {\n    authId,\n    desiredMode,\n    currentMode: state.mode,\n    id: instanceId,\n  });\n}\n\n/**\n * Map mode store\n */\nexport const modeStore = createMapStore<MapModeState, MapModeActions>({\n  defaultState: {\n    mode: DEFAULT_MODE,\n    modeOwners: new Map(),\n    pendingRequests: new Map(),\n  },\n\n  actions: (instanceId) => ({\n    requestModeChange: (desiredMode: string, requestOwner: string) => {\n      const trimmedDesiredMode = desiredMode.trim();\n      const trimmedRequestOwner = requestOwner.trim();\n\n      if (!trimmedDesiredMode) {\n        throw new Error('requestModeChange requires non-empty desiredMode');\n      }\n      if (!trimmedRequestOwner) {\n        throw new Error('requestModeChange requires non-empty requestOwner');\n      }\n\n      mapModeBus.emit(MapModeEvents.changeRequest, {\n        desiredMode: trimmedDesiredMode,\n        owner: trimmedRequestOwner,\n        id: instanceId,\n      });\n    },\n  }),\n\n  bus: (instanceId, { get, set }) => {\n    // Listen for mode change requests\n    const unsubRequest = mapModeBus.on(MapModeEvents.changeRequest, (event) => {\n      const { desiredMode, owner: requestOwner, id } = event.payload;\n\n      const state = get();\n      // Filter: only handle if targeted at this map\n      if (id !== instanceId || desiredMode === state.mode) {\n        return;\n      }\n\n      handleModeChangeRequest(\n        instanceId,\n        state,\n        desiredMode,\n        requestOwner,\n        set,\n      );\n    });\n\n    // Listen for authorization decisions\n    const unsubDecision = mapModeBus.on(\n      MapModeEvents.changeDecision,\n      (event) => {\n        const { id, approved, authId, owner } = event.payload;\n\n        // Filter: only handle if targeted at this map\n        if (id !== instanceId) {\n          return;\n        }\n\n        handleAuthorizationDecision(\n          instanceId,\n          get(),\n          { approved, authId, owner },\n          set,\n        );\n      },\n    );\n\n    // Listen for mode changes to handle pending requests\n    const unsubChanged = mapModeBus.on(MapModeEvents.changed, (event) => {\n      const { currentMode, previousMode, id } = event.payload;\n\n      // Filter: only handle if targeted at this map\n      if (id !== instanceId) {\n        return;\n      }\n\n      const state = get();\n      // When mode owner changes to default mode, handle pending requests\n      if (currentMode === DEFAULT_MODE && state.pendingRequests.size > 0) {\n        handlePendingRequestsOnDefaultMode(\n          instanceId,\n          state,\n          previousMode,\n          set,\n        );\n      }\n    });\n\n    return () => {\n      unsubRequest();\n      unsubDecision();\n      unsubChanged();\n    };\n  },\n});\n\n// =============================================================================\n// Convenience exports\n// =============================================================================\n\n/**\n * Get the current mode for a map instance\n */\nexport function getMode(mapId: UniqueId): string {\n  return modeStore.get(mapId).mode;\n}\n\n/**\n * Hook for current mode value\n */\nexport function useMode(mapId: UniqueId): string {\n  return modeStore.useSelector(mapId, (state) => state.mode);\n}\n\n/**\n * Get the owner of the current mode for a given map instance\n * @internal - For internal map-toolkit use only\n */\nexport function getCurrentModeOwner(instanceId: UniqueId): string | undefined {\n  const state = modeStore.get(instanceId);\n  return state.modeOwners.get(state.mode);\n}\n\n/**\n * Check if a given owner is registered as the owner of any mode.\n * This includes both active mode owners and pending mode requests.\n * @internal - For internal map-toolkit use only\n */\nexport function isRegisteredModeOwner(\n  instanceId: UniqueId,\n  owner: string,\n): boolean {\n  const state = modeStore.get(instanceId);\n\n  // Check active mode owners\n  for (const modeOwner of state.modeOwners.values()) {\n    if (modeOwner === owner) {\n      return true;\n    }\n  }\n\n  // Check pending mode requests (owner is the key in pendingRequests map)\n  if (state.pendingRequests.has(owner)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Manually clear map mode state for a specific instanceId.\n */\nexport function clearMapModeState(instanceId: UniqueId): void {\n  modeStore.clear(instanceId);\n}\n"],"mappings":"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"}

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

@@ -13,9 +13,9 @@
 
 'use client';
 
-import { getOrCreateRequestModeChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateSubscription } from "./store.js";
+import { modeStore } from "./store.js";
 import { MapContext } from "../deckgl/base-map/provider.js";
-import { useContext, useMemo, useSyncExternalStore } from "react";
+import { useContext, useMemo } from "react";
 
 //#region src/map-mode/use-map-mode.ts
 /**
@@ -60,11 +60,12 @@ function useMapMode(id) {
 	const contextId = useContext(MapContext);
 	const actualId = id ?? contextId;
 	if (!actualId) throw new Error("useMapMode requires either an id parameter or to be used within a MapProvider");
-	const mode = useSyncExternalStore(getOrCreateSubscription(actualId), getOrCreateSnapshot(actualId), getOrCreateServerSnapshot(actualId));
+	const mode = modeStore.useSelector(actualId, (state) => state.mode);
+	const { requestModeChange } = modeStore.actions(actualId);
 	return useMemo(() => ({
 		mode,
-		requestModeChange: getOrCreateRequestModeChange(actualId)
-	}), [mode, actualId]);
+		requestModeChange
+	}), [mode, requestModeChange]);
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"use-map-mode.js","names":[],"sources":["../../src/map-mode/use-map-mode.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, useMemo, useSyncExternalStore } from 'react';\nimport { MapContext } from '../deckgl/base-map/provider';\nimport {\n  getOrCreateRequestModeChange,\n  getOrCreateServerSnapshot,\n  getOrCreateSnapshot,\n  getOrCreateSubscription,\n} from './store';\nimport type { UniqueId } from '@accelint/core';\n\n/**\n * Return value for the useMapMode hook\n */\nexport type UseMapModeReturn = {\n  /** The current active map mode */\n  mode: string;\n  /** Function to request a mode change with ownership */\n  requestModeChange: (desiredMode: string, requestOwner: string) => void;\n};\n\n/**\n * Hook to access the map mode state and actions.\n *\n * This hook uses `useSyncExternalStore` to subscribe to map mode state changes,\n * providing concurrent-safe mode state updates. Uses a fan-out pattern where\n * a single bus listener per map instance notifies N React component subscribers.\n *\n * @param id - Optional map instance ID. If not provided, will use the ID from `MapContext`.\n * @returns The current map mode and requestModeChange 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) - uses context\n * // Only Deck.gl layer components can be children\n * function CustomDeckLayer() {\n *   const { mode, requestModeChange } = useMapMode();\n *\n *   const handleClick = (info: PickingInfo) => {\n *     requestModeChange('editing', 'custom-layer-id');\n *   };\n *\n *   return <ScatterplotLayer onClick={handleClick} />;\n * }\n * ```\n *\n * @example\n * ```tsx\n * // Outside MapProvider - pass id directly\n * function ExternalControl({ mapId }: { mapId: UniqueId }) {\n *   const { mode, requestModeChange } = useMapMode(mapId);\n *\n *   return <button onClick={() => requestModeChange('default', 'external')}>\n *     Reset to Default (current: {mode})\n *   </button>;\n * }\n * ```\n */\nexport function useMapMode(id?: UniqueId): UseMapModeReturn {\n  const contextId = useContext(MapContext);\n  const actualId = id ?? contextId;\n\n  if (!actualId) {\n    throw new Error(\n      'useMapMode 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 mode = 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      mode,\n      requestModeChange: getOrCreateRequestModeChange(actualId),\n    }),\n    [mode, actualId],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,SAAgB,WAAW,IAAiC;CAC1D,MAAM,YAAY,WAAW,WAAW;CACxC,MAAM,WAAW,MAAM;AAEvB,KAAI,CAAC,SACH,OAAM,IAAI,MACR,gFACD;CAKH,MAAM,OAAO,qBACX,wBAAwB,SAAS,EACjC,oBAAoB,SAAS,EAC7B,0BAA0B,SAAS,CACpC;AAGD,QAAO,eACE;EACL;EACA,mBAAmB,6BAA6B,SAAS;EAC1D,GACD,CAAC,MAAM,SAAS,CACjB"}
+{"version":3,"file":"use-map-mode.js","names":[],"sources":["../../src/map-mode/use-map-mode.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, useMemo } from 'react';\nimport { MapContext } from '../deckgl/base-map/provider';\nimport { modeStore } from './store';\nimport type { UniqueId } from '@accelint/core';\n\n/**\n * Return value for the useMapMode hook\n */\nexport type UseMapModeReturn = {\n  /** The current active map mode */\n  mode: string;\n  /** Function to request a mode change with ownership */\n  requestModeChange: (desiredMode: string, requestOwner: string) => void;\n};\n\n/**\n * Hook to access the map mode state and actions.\n *\n * This hook uses `useSyncExternalStore` to subscribe to map mode state changes,\n * providing concurrent-safe mode state updates. Uses a fan-out pattern where\n * a single bus listener per map instance notifies N React component subscribers.\n *\n * @param id - Optional map instance ID. If not provided, will use the ID from `MapContext`.\n * @returns The current map mode and requestModeChange 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) - uses context\n * // Only Deck.gl layer components can be children\n * function CustomDeckLayer() {\n *   const { mode, requestModeChange } = useMapMode();\n *\n *   const handleClick = (info: PickingInfo) => {\n *     requestModeChange('editing', 'custom-layer-id');\n *   };\n *\n *   return <ScatterplotLayer onClick={handleClick} />;\n * }\n * ```\n *\n * @example\n * ```tsx\n * // Outside MapProvider - pass id directly\n * function ExternalControl({ mapId }: { mapId: UniqueId }) {\n *   const { mode, requestModeChange } = useMapMode(mapId);\n *\n *   return <button onClick={() => requestModeChange('default', 'external')}>\n *     Reset to Default (current: {mode})\n *   </button>;\n * }\n * ```\n */\nexport function useMapMode(id?: UniqueId): UseMapModeReturn {\n  const contextId = useContext(MapContext);\n  const actualId = id ?? contextId;\n\n  if (!actualId) {\n    throw new Error(\n      'useMapMode requires either an id parameter or to be used within a MapProvider',\n    );\n  }\n\n  // Use selector to get just the mode string (primitive comparison works with useSyncExternalStore)\n  const mode = modeStore.useSelector(actualId, (state) => state.mode);\n\n  // Get actions separately (stable reference)\n  const { requestModeChange } = modeStore.actions(actualId);\n\n  // Memoize the return value to prevent unnecessary re-renders\n  return useMemo(\n    () => ({\n      mode,\n      requestModeChange,\n    }),\n    [mode, requestModeChange],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,SAAgB,WAAW,IAAiC;CAC1D,MAAM,YAAY,WAAW,WAAW;CACxC,MAAM,WAAW,MAAM;AAEvB,KAAI,CAAC,SACH,OAAM,IAAI,MACR,gFACD;CAIH,MAAM,OAAO,UAAU,YAAY,WAAW,UAAU,MAAM,KAAK;CAGnE,MAAM,EAAE,sBAAsB,UAAU,QAAQ,SAAS;AAGzD,QAAO,eACE;EACL;EACA;EACD,GACD,CAAC,MAAM,kBAAkB,CAC1B"}

package/dist/maplibre/index.d.ts

@@ -10,6 +10,6 @@
  * governing permissions and limitations under the License.
  */
 
-import { INITIAL_VIEW_STATE } from "./constants.js";
 import { useMapLibre } from "./hooks/use-maplibre.js";
-export { INITIAL_VIEW_STATE, useMapLibre };
+import { DEFAULT_VIEW_STATE } from "../shared/constants.js";
+export { DEFAULT_VIEW_STATE, useMapLibre };

package/dist/maplibre/index.js

@@ -11,7 +11,7 @@
  */
 
 
-import { INITIAL_VIEW_STATE } from "./constants.js";
+import { DEFAULT_VIEW_STATE } from "../shared/constants.js";
 import { useMapLibre } from "./hooks/use-maplibre.js";
 
-export { INITIAL_VIEW_STATE, useMapLibre };
+export { DEFAULT_VIEW_STATE, useMapLibre };