@accelint/map-toolkit 0.2.0 → 0.3.0

package/dist/map-mode/store.js

@@ -4,324 +4,303 @@ import { MapModeEvents } from './events.js';
 
 const DEFAULT_MODE = "default";
 const mapModeBus = Broadcast.getInstance();
-class MapModeStore {
-  constructor(id) {
-    this.id = id;
-    this.id = id;
-    this.setupEventListeners();
+const modeStore = /* @__PURE__ */ new Map();
+const componentSubscribers = /* @__PURE__ */ new Map();
+const busUnsubscribers = /* @__PURE__ */ new Map();
+const subscriptionCache = /* @__PURE__ */ new Map();
+const snapshotCache = /* @__PURE__ */ new Map();
+const requestModeChangeCache = /* @__PURE__ */ new Map();
+function getOrCreateState(instanceId) {
+  if (!modeStore.has(instanceId)) {
+    modeStore.set(instanceId, {
+      mode: DEFAULT_MODE,
+      modeOwners: /* @__PURE__ */ new Map(),
+      pendingRequests: /* @__PURE__ */ new Map()
+    });
   }
-  mode = DEFAULT_MODE;
-  defaultMode = DEFAULT_MODE;
-  modeOwners = /* @__PURE__ */ new Map();
-  pendingRequests = /* @__PURE__ */ new Map();
-  listeners = /* @__PURE__ */ new Set();
-  bus = mapModeBus;
-  unsubscribers = [];
-  /**
-   * Get current mode snapshot (for useSyncExternalStore)
-   */
-  getSnapshot = () => {
-    return this.mode;
-  };
-  /**
-   * Subscribe to mode changes (for useSyncExternalStore)
-   */
-  subscribe = (listener) => {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  };
-  /**
-   * Request a mode change
-   *
-   * If the mode change can be auto-accepted (no ownership conflicts), the mode changes immediately.
-   * Otherwise, an authorization request is emitted and stored as a pending request.
-   *
-   * **Important**: If the requester already has a pending authorization request, it will be replaced
-   * with this new request. Only one pending request per requester is maintained at a time.
-   *
-   * @param desiredMode - The mode to switch to (automatically trimmed of whitespace)
-   * @param requestOwner - Unique identifier of the component requesting the change (automatically trimmed of whitespace)
-   * @throws Error if either parameter is empty or whitespace-only
-   *
-   * @example
-   * ```ts
-   * // First request from 'drawing-tool'
-   * store.requestModeChange('drawing', 'drawing-tool');
-   * // → Creates pending request with authId 'abc-123'
-   *
-   * // Second request from same 'drawing-tool' before first is resolved
-   * store.requestModeChange('measuring', 'drawing-tool');
-   * // → Replaces pending request, new authId 'def-456', old 'abc-123' is discarded
-   * ```
-   */
-  requestModeChange = (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");
+  return modeStore.get(instanceId);
+}
+function notifySubscribers(instanceId) {
+  const subscribers = componentSubscribers.get(instanceId);
+  if (subscribers) {
+    for (const onStoreChange of subscribers) {
+      onStoreChange();
     }
-    this.bus.emit(MapModeEvents.changeRequest, {
-      desiredMode: trimmedDesiredMode,
-      owner: trimmedRequestOwner,
-      id: this.id
-    });
-  };
-  /**
-   * Notify all subscribers of state change
-   */
-  notify() {
-    for (const listener of this.listeners) {
-      listener();
+  }
+}
+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;
+}
+function setMode(instanceId, state, newMode) {
+  const previousMode = state.mode;
+  state.mode = newMode;
+  mapModeBus.emit(MapModeEvents.changed, {
+    previousMode,
+    currentMode: newMode,
+    id: instanceId
+  });
+  notifySubscribers(instanceId);
+}
+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);
     }
   }
-  /**
-   * Setup event listeners for bus events
-   *
-   * Note: Event listeners remain active even after early returns in handlers.
-   * This is by design - cleanup happens in destroy() which is called automatically
-   * by MapProvider on unmount. Consumers don't need to manually manage cleanup.
-   */
-  setupEventListeners() {
-    const unsubRequest = this.bus.on(MapModeEvents.changeRequest, (event) => {
-      const { desiredMode, owner: requestOwner, id } = event.payload;
-      if (id !== this.id || desiredMode === this.mode) {
-        return;
-      }
-      this.handleModeChangeRequest(desiredMode, requestOwner);
-    });
-    this.unsubscribers.push(unsubRequest);
-    const unsubDecision = this.bus.on(MapModeEvents.changeDecision, (event) => {
-      const { id, approved, authId, owner } = event.payload;
-      if (id !== this.id) {
-        return;
-      }
-      this.handleAuthorizationDecision({ approved, authId, owner });
+  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
     });
-    this.unsubscribers.push(unsubDecision);
-    const unsubChanged = this.bus.on(MapModeEvents.changed, (event) => {
-      const { currentMode, previousMode, id } = event.payload;
-      if (id !== this.id) {
-        return;
-      }
-      if (currentMode === this.defaultMode && this.pendingRequests.size > 0) {
-        this.handlePendingRequestsOnDefaultMode(previousMode);
-      }
+  }
+  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
     });
-    this.unsubscribers.push(unsubChanged);
   }
-  /**
-   * Determine if a mode change request should be auto-accepted without authorization
-   */
-  shouldAutoAcceptRequest(desiredMode, requestOwner, currentModeOwner, desiredModeOwner) {
-    if (desiredMode === this.defaultMode && requestOwner === currentModeOwner) {
-      return true;
-    }
-    if (requestOwner === currentModeOwner) {
-      return true;
-    }
-    if (!(currentModeOwner || desiredModeOwner)) {
-      return true;
-    }
-    if (this.mode === this.defaultMode && requestOwner === desiredModeOwner) {
-      return true;
+}
+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
+      });
     }
-    return false;
+  } else {
+    approveRequestAndRejectOthers(
+      instanceId,
+      state,
+      firstEntry,
+      firstEntry.authId,
+      previousModeOwner,
+      "Auto-accepted when mode owner returned to default",
+      true
+    );
   }
-  /**
-   * Handle mode change request logic
-   */
-  handleModeChangeRequest(desiredMode, requestOwner) {
-    const currentModeOwner = this.modeOwners.get(this.mode);
-    const desiredModeOwner = this.modeOwners.get(desiredMode);
-    if (this.shouldAutoAcceptRequest(
-      desiredMode,
-      requestOwner,
-      currentModeOwner,
-      desiredModeOwner
-    )) {
-      this.setMode(desiredMode);
-      if (desiredMode !== this.defaultMode && !desiredModeOwner) {
-        this.modeOwners.set(desiredMode, requestOwner);
-      }
-      this.pendingRequests.delete(requestOwner);
-      return;
+}
+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;
     }
-    const authId = uuid();
-    this.pendingRequests.set(requestOwner, {
-      authId,
-      desiredMode,
-      currentMode: this.mode,
-      requestOwner
-    });
-    this.bus.emit(MapModeEvents.changeAuthorization, {
+  }
+  if (!(matchingRequest && matchingRequestOwner)) {
+    return;
+  }
+  if (approved) {
+    approveRequestAndRejectOthers(
+      instanceId,
+      state,
+      matchingRequest,
       authId,
-      desiredMode,
-      currentMode: this.mode,
-      id: this.id
-    });
+      decisionOwner,
+      "",
+      false
+    );
+  } else {
+    state.pendingRequests.delete(matchingRequestOwner);
   }
-  /**
-   * 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 payload - The authorization decision containing authId, approved status, and owner
-   */
-  handleAuthorizationDecision(payload) {
-    const { approved, authId, owner: decisionOwner } = payload;
-    const currentModeOwner = this.modeOwners.get(this.mode);
-    if (decisionOwner !== currentModeOwner) {
-      console.warn(
-        `[MapMode] Authorization decision from "${decisionOwner}" ignored - not the owner of mode "${this.mode}" (owner: ${currentModeOwner || "none"})`
-      );
-      return;
-    }
-    let matchingRequestOwner = null;
-    let matchingRequest = null;
-    for (const [requestOwner, request] of this.pendingRequests.entries()) {
-      if (request.authId === authId) {
-        matchingRequestOwner = requestOwner;
-        matchingRequest = request;
-        break;
-      }
+}
+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);
     }
-    if (!(matchingRequest && matchingRequestOwner)) {
+    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
+  });
+}
+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;
     }
-    if (approved) {
-      this.approveRequestAndRejectOthers(
-        matchingRequest,
-        authId,
-        decisionOwner,
-        "",
-        false
-      );
-    } else {
-      this.pendingRequests.delete(matchingRequestOwner);
-    }
-  }
-  /**
-   * Approve a request and reject all others
-   */
-  approveRequestAndRejectOthers(approvedRequest, excludeAuthId, decisionOwner, reason, emitApproval) {
-    const requestsToReject = [];
-    for (const request of this.pendingRequests.values()) {
-      if (request.authId !== excludeAuthId) {
-        requestsToReject.push(request);
-      }
+    handleModeChangeRequest(instanceId, state, desiredMode, requestOwner);
+  });
+  const unsubDecision = mapModeBus.on(MapModeEvents.changeDecision, (event) => {
+    const { id, approved, authId, owner } = event.payload;
+    if (id !== instanceId) {
+      return;
     }
-    this.pendingRequests.clear();
-    this.setMode(approvedRequest.desiredMode);
-    if (approvedRequest.desiredMode !== this.defaultMode) {
-      this.modeOwners.set(
-        approvedRequest.desiredMode,
-        approvedRequest.requestOwner
-      );
+    handleAuthorizationDecision(instanceId, state, { approved, authId, owner });
+  });
+  const unsubChanged = mapModeBus.on(MapModeEvents.changed, (event) => {
+    const { currentMode, previousMode, id } = event.payload;
+    if (id !== instanceId) {
+      return;
     }
-    if (emitApproval) {
-      this.bus.emit(MapModeEvents.changeDecision, {
-        authId: approvedRequest.authId,
-        approved: true,
-        owner: decisionOwner,
-        reason,
-        id: this.id
-      });
+    if (currentMode === DEFAULT_MODE && state.pendingRequests.size > 0) {
+      handlePendingRequestsOnDefaultMode(instanceId, state, previousMode);
     }
-    for (const request of requestsToReject) {
-      this.bus.emit(MapModeEvents.changeDecision, {
-        authId: request.authId,
-        approved: false,
-        owner: decisionOwner,
-        reason: "Request auto-rejected because another request was approved",
-        id: this.id
-      });
+  });
+  busUnsubscribers.set(instanceId, () => {
+    unsubRequest();
+    unsubDecision();
+    unsubChanged();
+  });
+}
+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);
   }
-  /**
-   * Handle pending requests when returning to default mode
-   */
-  handlePendingRequestsOnDefaultMode(previousMode) {
-    const firstEntry = Array.from(this.pendingRequests.values())[0];
-    if (!firstEntry) {
-      return;
-    }
-    const previousModeOwner = this.modeOwners.get(previousMode);
-    if (!previousModeOwner) {
-      return;
+}
+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);
     }
-    if (firstEntry.desiredMode === this.defaultMode) {
-      const allRequests = Array.from(this.pendingRequests.values());
-      this.pendingRequests.clear();
-      for (const request of allRequests) {
-        this.bus.emit(MapModeEvents.changeDecision, {
-          authId: request.authId,
-          approved: false,
-          owner: previousModeOwner,
-          reason: "Request rejected - already in requested mode",
-          id: this.id
-        });
+    subscriberSet.add(onStoreChange);
+    return () => {
+      const currentSubscriberSet = componentSubscribers.get(instanceId);
+      if (currentSubscriberSet) {
+        currentSubscriberSet.delete(onStoreChange);
       }
-    } else {
-      this.approveRequestAndRejectOthers(
-        firstEntry,
-        firstEntry.authId,
-        previousModeOwner,
-        "Auto-accepted when mode owner returned to default",
-        true
-      );
+      cleanupBusListenerIfNeeded(instanceId);
+    };
+  });
+  subscriptionCache.set(instanceId, subscription);
+  return subscription;
+}
+function getOrCreateSnapshot(instanceId) {
+  const snapshot = snapshotCache.get(instanceId) ?? (() => {
+    const state = modeStore.get(instanceId);
+    if (!state) {
+      return DEFAULT_MODE;
     }
-  }
-  /**
-   * Set mode and notify listeners
-   */
-  setMode(newMode) {
-    const previousMode = this.mode;
-    this.mode = newMode;
-    this.bus.emit(MapModeEvents.changed, {
-      previousMode,
-      currentMode: newMode,
-      id: this.id
-    });
-    this.notify();
-  }
-  /**
-   * Clean up store resources
-   */
-  destroy() {
-    for (const unsubscribe of this.unsubscribers) {
-      unsubscribe();
+    return state.mode;
+  });
+  snapshotCache.set(instanceId, snapshot);
+  return snapshot;
+}
+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");
     }
-    this.unsubscribers.length = 0;
-    this.modeOwners.clear();
-    this.pendingRequests.clear();
-    this.listeners.clear();
-  }
+    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 storeRegistry = /* @__PURE__ */ new Map();
-function getOrCreateStore(id) {
-  if (!storeRegistry.has(id)) {
-    storeRegistry.set(id, new MapModeStore(id));
+function getCurrentModeOwner(instanceId) {
+  const state = modeStore.get(instanceId);
+  if (!state) {
+    return void 0;
   }
-  return storeRegistry.get(id);
+  return state.modeOwners.get(state.mode);
 }
-function destroyStore(id) {
-  const store = storeRegistry.get(id);
-  if (store) {
-    store.destroy();
-    storeRegistry.delete(id);
+function clearMapModeState(instanceId) {
+  const unsub = busUnsubscribers.get(instanceId);
+  if (unsub) {
+    unsub();
+    busUnsubscribers.delete(instanceId);
   }
-}
-function getStore(id) {
-  return storeRegistry.get(id);
+  modeStore.delete(instanceId);
+  componentSubscribers.delete(instanceId);
+  subscriptionCache.delete(instanceId);
+  snapshotCache.delete(instanceId);
+  requestModeChangeCache.delete(instanceId);
 }
 
-export { MapModeStore, destroyStore, getOrCreateStore, getStore };
+export { clearMapModeState, getCurrentModeOwner, getOrCreateRequestModeChange, getOrCreateSnapshot, getOrCreateSubscription };
 //# sourceMappingURL=store.js.map
 //# sourceMappingURL=store.js.map