@accelint/map-toolkit 0.3.0 → 0.4.0

package/dist/map-mode/store.js

@@ -1,306 +1,370 @@
-import { Broadcast } from '@accelint/bus';
-import { uuid } from '@accelint/core';
-import { MapModeEvents } from './events.js';
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
 
+
+import { MapModeEvents } from "./events.js";
+import { Broadcast } from "@accelint/bus";
+import { uuid } from "@accelint/core";
+
+//#region src/map-mode/store.ts
 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);
+	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();
-    }
-  }
+	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) {
-  const currentModeOwner = state.modeOwners.get(state.mode);
-  const desiredModeOwner = state.modeOwners.get(desiredMode);
-  if (desiredMode === DEFAULT_MODE && requestOwner === currentModeOwner) {
-    return true;
-  }
-  if (requestOwner === currentModeOwner) {
-    return true;
-  }
-  if (!(currentModeOwner || desiredModeOwner)) {
-    return true;
-  }
-  if (state.mode === DEFAULT_MODE && requestOwner === desiredModeOwner) {
-    return true;
-  }
-  return false;
+	const currentModeOwner = state.modeOwners.get(state.mode);
+	const desiredModeOwner = state.modeOwners.get(desiredMode);
+	if (desiredMode === DEFAULT_MODE && requestOwner === currentModeOwner) return true;
+	if (requestOwner === currentModeOwner) return true;
+	if (!(currentModeOwner || desiredModeOwner)) return true;
+	if (state.mode === DEFAULT_MODE && requestOwner === desiredModeOwner) return true;
+	return false;
 }
+/**
+* Set mode and emit change event
+*/
 function setMode(instanceId, state, newMode) {
-  const previousMode = state.mode;
-  state.mode = newMode;
-  mapModeBus.emit(MapModeEvents.changed, {
-    previousMode,
-    currentMode: newMode,
-    id: instanceId
-  });
-  notifySubscribers(instanceId);
+	const previousMode = state.mode;
+	state.mode = newMode;
+	mapModeBus.emit(MapModeEvents.changed, {
+		previousMode,
+		currentMode: newMode,
+		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,
-      owner: decisionOwner,
-      reason,
-      id: instanceId
-    });
-  }
-  for (const request of requestsToReject) {
-    mapModeBus.emit(MapModeEvents.changeDecision, {
-      authId: request.authId,
-      approved: false,
-      owner: decisionOwner,
-      reason: "Request auto-rejected because another request was approved",
-      id: instanceId
-    });
-  }
+	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,
+		owner: decisionOwner,
+		reason,
+		id: instanceId
+	});
+	for (const request of requestsToReject) mapModeBus.emit(MapModeEvents.changeDecision, {
+		authId: request.authId,
+		approved: false,
+		owner: decisionOwner,
+		reason: "Request auto-rejected because another request was approved",
+		id: instanceId
+	});
 }
+/**
+* Handle pending requests when returning to default mode
+*/
 function handlePendingRequestsOnDefaultMode(instanceId, state, previousMode) {
-  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();
-    for (const request of allRequests) {
-      mapModeBus.emit(MapModeEvents.changeDecision, {
-        authId: request.authId,
-        approved: false,
-        owner: previousModeOwner,
-        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
-    );
-  }
+	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();
+		for (const request of allRequests) mapModeBus.emit(MapModeEvents.changeDecision, {
+			authId: request.authId,
+			approved: false,
+			owner: previousModeOwner,
+			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);
 }
+/**
+* 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
+*/
 function handleAuthorizationDecision(instanceId, state, payload) {
-  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"})`
-    );
-    return;
-  }
-  let matchingRequestOwner = null;
-  let matchingRequest = null;
-  for (const [requestOwner, request] of state.pendingRequests.entries()) {
-    if (request.authId === authId) {
-      matchingRequestOwner = requestOwner;
-      matchingRequest = request;
-      break;
-    }
-  }
-  if (!(matchingRequest && matchingRequestOwner)) {
-    return;
-  }
-  if (approved) {
-    approveRequestAndRejectOthers(
-      instanceId,
-      state,
-      matchingRequest,
-      authId,
-      decisionOwner,
-      "",
-      false
-    );
-  } else {
-    state.pendingRequests.delete(matchingRequestOwner);
-  }
+	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"})`);
+		return;
+	}
+	let matchingRequestOwner = null;
+	let matchingRequest = null;
+	for (const [requestOwner, request] of state.pendingRequests.entries()) if (request.authId === authId) {
+		matchingRequestOwner = requestOwner;
+		matchingRequest = request;
+		break;
+	}
+	if (!(matchingRequest && matchingRequestOwner)) return;
+	if (approved) approveRequestAndRejectOthers(instanceId, state, matchingRequest, authId, decisionOwner, "", false);
+	else state.pendingRequests.delete(matchingRequestOwner);
 }
+/**
+* Handle mode change request logic
+*/
 function handleModeChangeRequest(instanceId, state, desiredMode, requestOwner) {
-  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);
-    return;
-  }
-  const authId = uuid();
-  state.pendingRequests.set(requestOwner, {
-    authId,
-    desiredMode,
-    currentMode: state.mode,
-    requestOwner
-  });
-  mapModeBus.emit(MapModeEvents.changeAuthorization, {
-    authId,
-    desiredMode,
-    currentMode: state.mode,
-    id: instanceId
-  });
+	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);
+		return;
+	}
+	const authId = uuid();
+	state.pendingRequests.set(requestOwner, {
+		authId,
+		desiredMode,
+		currentMode: state.mode,
+		requestOwner
+	});
+	mapModeBus.emit(MapModeEvents.changeAuthorization, {
+		authId,
+		desiredMode,
+		currentMode: state.mode,
+		id: instanceId
+	});
 }
+/**
+* Ensures a single bus listener exists for the given instanceId.
+* All React subscribers will be notified via fan-out when the bus events fire.
+* This prevents creating N bus listeners for N React components.
+*
+* @param instanceId - The unique identifier for the map mode instance
+*/
 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();
-  });
+	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);
-    requestModeChangeCache.delete(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;
+	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;
+	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 trimmedDesiredMode = desiredMode.trim();
-    const trimmedRequestOwner = requestOwner.trim();
-    if (!trimmedDesiredMode) {
-      throw new Error("requestModeChange requires non-empty desiredMode");
-    }
-    if (!trimmedRequestOwner) {
-      throw new Error("requestModeChange requires non-empty requestOwner");
-    }
-    mapModeBus.emit(MapModeEvents.changeRequest, {
-      desiredMode: trimmedDesiredMode,
-      owner: trimmedRequestOwner,
-      id: instanceId
-    });
-  });
-  requestModeChangeCache.set(instanceId, requestModeChange);
-  return requestModeChange;
+	const requestModeChange = requestModeChangeCache.get(instanceId) ?? ((desiredMode, requestOwner) => {
+		const trimmedDesiredMode = desiredMode.trim();
+		const trimmedRequestOwner = requestOwner.trim();
+		if (!trimmedDesiredMode) throw new Error("requestModeChange requires non-empty desiredMode");
+		if (!trimmedRequestOwner) throw new Error("requestModeChange requires non-empty requestOwner");
+		mapModeBus.emit(MapModeEvents.changeRequest, {
+			desiredMode: trimmedDesiredMode,
+			owner: trimmedRequestOwner,
+			id: instanceId
+		});
+	});
+	requestModeChangeCache.set(instanceId, requestModeChange);
+	return requestModeChange;
 }
+/**
+* Get the owner of the current mode for a given map instance
+* @internal - For internal map-toolkit use only
+*/
 function getCurrentModeOwner(instanceId) {
-  const state = modeStore.get(instanceId);
-  if (!state) {
-    return void 0;
-  }
-  return state.modeOwners.get(state.mode);
+	const state = modeStore.get(instanceId);
+	if (!state) return;
+	return state.modeOwners.get(state.mode);
 }
+/**
+* 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);
-  requestModeChangeCache.delete(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);
 }
 
-export { clearMapModeState, getCurrentModeOwner, getOrCreateRequestModeChange, getOrCreateSnapshot, getOrCreateSubscription };
-//# sourceMappingURL=store.js.map
+//#endregion
+export { clearMapModeState, getCurrentModeOwner, getOrCreateRequestModeChange, getOrCreateServerSnapshot, getOrCreateSnapshot, getOrCreateSubscription };
 //# sourceMappingURL=store.js.map