@embedpdf/plugin-selection 1.4.1 → 2.0.0-next.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { BasePlugin, createBehaviorEmitter, createEmitter, SET_DOCUMENT, REFRESH_PAGES } from "@embedpdf/core";
+import { BasePlugin, createScopedEmitter, REFRESH_PAGES } from "@embedpdf/core";
 import { boundingRect, Task, ignore, PdfErrorCode, PdfTaskHelper } from "@embedpdf/models";
 const SELECTION_PLUGIN_ID = "selection";
 const manifest = {
@@ -7,36 +7,156 @@ const manifest = {
   version: "1.0.0",
   provides: ["selection"],
   requires: ["interaction-manager"],
-  optional: [],
+  optional: ["viewport", "scroll"],
   defaultConfig: {
     enabled: true
   }
 };
-const CACHE_PAGE_GEOMETRY = "CACHE_PAGE_GEOMETRY";
-const SET_SELECTION = "SET_SELECTION";
-const START_SELECTION = "START_SELECTION";
-const END_SELECTION = "END_SELECTION";
-const CLEAR_SELECTION = "CLEAR_SELECTION";
-const SET_RECTS = "SET_RECTS";
-const SET_SLICES = "SET_SLICES";
-const RESET = "RESET";
-const cachePageGeometry = (page, geo) => ({
+const INIT_SELECTION_STATE = "SELECTION/INIT_STATE";
+const CLEANUP_SELECTION_STATE = "SELECTION/CLEANUP_STATE";
+const CACHE_PAGE_GEOMETRY = "SELECTION/CACHE_PAGE_GEOMETRY";
+const SET_SELECTION = "SELECTION/SET_SELECTION";
+const START_SELECTION = "SELECTION/START_SELECTION";
+const END_SELECTION = "SELECTION/END_SELECTION";
+const CLEAR_SELECTION = "SELECTION/CLEAR_SELECTION";
+const SET_RECTS = "SELECTION/SET_RECTS";
+const SET_SLICES = "SELECTION/SET_SLICES";
+const RESET = "SELECTION/RESET";
+const initSelectionState = (documentId, state) => ({
+  type: INIT_SELECTION_STATE,
+  payload: { documentId, state }
+});
+const cleanupSelectionState = (documentId) => ({
+  type: CLEANUP_SELECTION_STATE,
+  payload: documentId
+});
+const cachePageGeometry = (documentId, page, geo) => ({
   type: CACHE_PAGE_GEOMETRY,
-  payload: { page, geo }
+  payload: { documentId, page, geo }
 });
-const setSelection = (sel) => ({
+const setSelection = (documentId, sel) => ({
   type: SET_SELECTION,
-  payload: sel
+  payload: { documentId, selection: sel }
+});
+const startSelection = (documentId) => ({
+  type: START_SELECTION,
+  payload: { documentId }
 });
-const startSelection = () => ({ type: START_SELECTION });
-const endSelection = () => ({ type: END_SELECTION });
-const clearSelection = () => ({ type: CLEAR_SELECTION });
-const setRects = (allRects) => ({
+const endSelection = (documentId) => ({
+  type: END_SELECTION,
+  payload: { documentId }
+});
+const clearSelection = (documentId) => ({
+  type: CLEAR_SELECTION,
+  payload: { documentId }
+});
+const setRects = (documentId, allRects) => ({
   type: SET_RECTS,
-  payload: allRects
+  payload: { documentId, rects: allRects }
+});
+const setSlices = (documentId, slices) => ({ type: SET_SLICES, payload: { documentId, slices } });
+const initialSelectionDocumentState = {
+  geometry: {},
+  rects: {},
+  slices: {},
+  selection: null,
+  active: false,
+  selecting: false
+};
+const initialState = {
+  documents: {}
+};
+const updateDocState = (state, documentId, newDocState) => ({
+  ...state,
+  documents: {
+    ...state.documents,
+    [documentId]: newDocState
+  }
 });
-const setSlices = (slices) => ({ type: SET_SLICES, payload: slices });
-const reset = () => ({ type: RESET });
+const selectionReducer = (state = initialState, action) => {
+  switch (action.type) {
+    case INIT_SELECTION_STATE: {
+      const { documentId, state: docState } = action.payload;
+      return updateDocState(state, documentId, docState);
+    }
+    case CLEANUP_SELECTION_STATE: {
+      const documentId = action.payload;
+      const { [documentId]: removed, ...remaining } = state.documents;
+      return {
+        ...state,
+        documents: remaining
+      };
+    }
+    case CACHE_PAGE_GEOMETRY: {
+      const { documentId, page, geo } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, {
+        ...docState,
+        geometry: { ...docState.geometry, [page]: geo }
+      });
+    }
+    case SET_SELECTION: {
+      const { documentId, selection } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, {
+        ...docState,
+        selection,
+        active: true
+      });
+    }
+    case START_SELECTION: {
+      const { documentId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, {
+        ...docState,
+        selecting: true,
+        selection: null,
+        rects: {}
+      });
+    }
+    case END_SELECTION: {
+      const { documentId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, { ...docState, selecting: false });
+    }
+    case CLEAR_SELECTION: {
+      const { documentId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, {
+        ...docState,
+        selecting: false,
+        selection: null,
+        rects: {},
+        active: false
+      });
+    }
+    case SET_RECTS: {
+      const { documentId, rects } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, { ...docState, rects });
+    }
+    case SET_SLICES: {
+      const { documentId, slices } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, { ...docState, slices });
+    }
+    case RESET: {
+      const { documentId } = action.payload;
+      const docState = state.documents[documentId];
+      if (!docState) return state;
+      return updateDocState(state, documentId, initialSelectionDocumentState);
+    }
+    default:
+      return state;
+  }
+};
 function selectRectsForPage(state, page) {
   return state.rects[page] ?? [];
 }
@@ -208,266 +328,425 @@ function mergeAdjacentRects(textRuns) {
 }
 const _SelectionPlugin = class _SelectionPlugin extends BasePlugin {
   constructor(id, registry) {
-    var _a;
+    var _a, _b, _c;
     super(id, registry);
-    this.enabledModes = /* @__PURE__ */ new Set(["pointerMode"]);
-    this.selecting = false;
+    this.enabledModesPerDoc = /* @__PURE__ */ new Map();
+    this.selecting = /* @__PURE__ */ new Map();
+    this.anchor = /* @__PURE__ */ new Map();
     this.pageCallbacks = /* @__PURE__ */ new Map();
-    this.selChange$ = createBehaviorEmitter();
-    this.textRetrieved$ = createBehaviorEmitter();
-    this.copyToClipboard$ = createEmitter();
-    this.beginSelection$ = createEmitter();
-    this.endSelection$ = createEmitter();
-    this.interactionManagerCapability = (_a = this.registry.getPlugin("interaction-manager")) == null ? void 0 : _a.provides();
-    this.coreStore.onAction(SET_DOCUMENT, (_action) => {
-      this.dispatch(reset());
-      this.notifyAllPages();
-    });
+    this.menuPlacement$ = createScopedEmitter((documentId, placement) => ({ documentId, placement }));
+    this.selChange$ = createScopedEmitter((documentId, selection) => ({ documentId, selection }));
+    this.textRetrieved$ = createScopedEmitter(
+      (documentId, text) => ({ documentId, text })
+    );
+    this.copyToClipboard$ = createScopedEmitter(
+      (documentId, text) => ({ documentId, text }),
+      { cache: false }
+    );
+    this.beginSelection$ = createScopedEmitter((documentId, data) => ({ documentId, page: data.page, index: data.index }), { cache: false });
+    this.endSelection$ = createScopedEmitter(
+      (documentId) => ({ documentId }),
+      { cache: false }
+    );
+    this.viewportCapability = null;
+    this.scrollCapability = null;
+    const imPlugin = registry.getPlugin("interaction-manager");
+    if (!imPlugin) {
+      throw new Error("SelectionPlugin: InteractionManagerPlugin is required.");
+    }
+    this.interactionManagerCapability = imPlugin.provides();
+    this.viewportCapability = ((_a = registry.getPlugin("viewport")) == null ? void 0 : _a.provides()) ?? null;
+    this.scrollCapability = ((_b = registry.getPlugin("scroll")) == null ? void 0 : _b.provides()) ?? null;
     this.coreStore.onAction(REFRESH_PAGES, (action) => {
-      const tasks = action.payload.map((pageIdx) => this.getNewPageGeometryAndCache(pageIdx));
+      const { documentId, pageIndexes } = action.payload;
+      const tasks = pageIndexes.map(
+        (pageIndex) => this.getNewPageGeometryAndCache(documentId, pageIndex)
+      );
       Task.all(tasks).wait(() => {
-        action.payload.forEach((pageIdx) => {
-          this.notifyPage(pageIdx);
+        pageIndexes.forEach((pageIndex) => {
+          this.notifyPage(documentId, pageIndex);
         });
       }, ignore);
     });
+    (_c = this.viewportCapability) == null ? void 0 : _c.onViewportChange(
+      (event) => {
+        this.recalculateMenuPlacement(event.documentId);
+      },
+      { mode: "throttle", wait: 100 }
+    );
   }
   /* ── life-cycle ────────────────────────────────────────── */
+  onDocumentLoadingStarted(documentId) {
+    this.dispatch(initSelectionState(documentId, initialSelectionDocumentState));
+    this.enabledModesPerDoc.set(documentId, /* @__PURE__ */ new Set(["pointerMode"]));
+    this.pageCallbacks.set(documentId, /* @__PURE__ */ new Map());
+    this.selecting.set(documentId, false);
+    this.anchor.set(documentId, void 0);
+  }
+  onDocumentClosed(documentId) {
+    this.dispatch(cleanupSelectionState(documentId));
+    this.enabledModesPerDoc.delete(documentId);
+    this.pageCallbacks.delete(documentId);
+    this.selecting.delete(documentId);
+    this.anchor.delete(documentId);
+    this.selChange$.clearScope(documentId);
+    this.textRetrieved$.clearScope(documentId);
+    this.copyToClipboard$.clearScope(documentId);
+    this.beginSelection$.clearScope(documentId);
+    this.endSelection$.clearScope(documentId);
+    this.menuPlacement$.clearScope(documentId);
+  }
   async initialize() {
   }
   async destroy() {
     this.selChange$.clear();
+    this.textRetrieved$.clear();
+    this.copyToClipboard$.clear();
+    this.beginSelection$.clear();
+    this.endSelection$.clear();
+    this.menuPlacement$.clear();
+    super.destroy();
   }
   /* ── capability exposed to UI / other plugins ─────────── */
   buildCapability() {
+    const getDocId = (documentId) => documentId ?? this.getActiveDocumentId();
+    return {
+      // Active document operations
+      getFormattedSelection: (docId) => getFormattedSelection(this.getDocumentState(getDocId(docId))),
+      getFormattedSelectionForPage: (p, docId) => getFormattedSelectionForPage(this.getDocumentState(getDocId(docId)), p),
+      getHighlightRectsForPage: (p, docId) => selectRectsForPage(this.getDocumentState(getDocId(docId)), p),
+      getHighlightRects: (docId) => this.getDocumentState(getDocId(docId)).rects,
+      getBoundingRectForPage: (p, docId) => selectBoundingRectForPage(this.getDocumentState(getDocId(docId)), p),
+      getBoundingRects: (docId) => selectBoundingRectsForAllPages(this.getDocumentState(getDocId(docId))),
+      getSelectedText: (docId) => this.getSelectedText(getDocId(docId)),
+      clear: (docId) => this.clearSelection(getDocId(docId)),
+      copyToClipboard: (docId) => this.copyToClipboard(getDocId(docId)),
+      getState: (docId) => this.getDocumentState(getDocId(docId)),
+      enableForMode: (modeId, docId) => {
+        var _a;
+        return (_a = this.enabledModesPerDoc.get(getDocId(docId))) == null ? void 0 : _a.add(modeId);
+      },
+      isEnabledForMode: (modeId, docId) => {
+        var _a;
+        return ((_a = this.enabledModesPerDoc.get(getDocId(docId))) == null ? void 0 : _a.has(modeId)) ?? false;
+      },
+      // Document-scoped operations
+      forDocument: this.createSelectionScope.bind(this),
+      // Global events
+      onCopyToClipboard: this.copyToClipboard$.onGlobal,
+      onSelectionChange: this.selChange$.onGlobal,
+      onTextRetrieved: this.textRetrieved$.onGlobal,
+      onBeginSelection: this.beginSelection$.onGlobal,
+      onEndSelection: this.endSelection$.onGlobal
+    };
+  }
+  createSelectionScope(documentId) {
     return {
-      getFormattedSelection: () => getFormattedSelection(this.state),
-      getFormattedSelectionForPage: (p) => getFormattedSelectionForPage(this.state, p),
-      getHighlightRectsForPage: (p) => selectRectsForPage(this.state, p),
-      getHighlightRects: () => this.state.rects,
-      getBoundingRectForPage: (p) => selectBoundingRectForPage(this.state, p),
-      getBoundingRects: () => selectBoundingRectsForAllPages(this.state),
-      onCopyToClipboard: this.copyToClipboard$.on,
-      onSelectionChange: this.selChange$.on,
-      onTextRetrieved: this.textRetrieved$.on,
-      onBeginSelection: this.beginSelection$.on,
-      onEndSelection: this.endSelection$.on,
-      clear: () => this.clearSelection(),
-      getSelectedText: () => this.getSelectedText(),
-      copyToClipboard: () => this.copyToClipboard(),
-      enableForMode: (id) => this.enabledModes.add(id),
-      isEnabledForMode: (id) => this.enabledModes.has(id),
-      getState: () => this.state
+      getFormattedSelection: () => getFormattedSelection(this.getDocumentState(documentId)),
+      getFormattedSelectionForPage: (p) => getFormattedSelectionForPage(this.getDocumentState(documentId), p),
+      getHighlightRectsForPage: (p) => selectRectsForPage(this.getDocumentState(documentId), p),
+      getHighlightRects: () => this.getDocumentState(documentId).rects,
+      getBoundingRectForPage: (p) => selectBoundingRectForPage(this.getDocumentState(documentId), p),
+      getBoundingRects: () => selectBoundingRectsForAllPages(this.getDocumentState(documentId)),
+      getSelectedText: () => this.getSelectedText(documentId),
+      clear: () => this.clearSelection(documentId),
+      copyToClipboard: () => this.copyToClipboard(documentId),
+      getState: () => this.getDocumentState(documentId),
+      onSelectionChange: this.selChange$.forScope(documentId),
+      onTextRetrieved: this.textRetrieved$.forScope(documentId),
+      onCopyToClipboard: this.copyToClipboard$.forScope(documentId),
+      onBeginSelection: this.beginSelection$.forScope(documentId),
+      onEndSelection: this.endSelection$.forScope(documentId)
     };
   }
+  getDocumentState(documentId) {
+    const state = this.state.documents[documentId];
+    if (!state) {
+      throw new Error(`Selection state not found for document: ${documentId}`);
+    }
+    return state;
+  }
+  /**
+   * Subscribe to menu placement changes for a specific document
+   * @param documentId - The document ID to subscribe to
+   * @param listener - Callback function that receives placement updates
+   * @returns Unsubscribe function
+   */
+  onMenuPlacement(documentId, listener) {
+    return this.menuPlacement$.forScope(documentId)(listener);
+  }
   registerSelectionOnPage(opts) {
-    if (!this.interactionManagerCapability) {
+    var _a;
+    const { documentId, pageIndex, onRectsChange } = opts;
+    const docState = this.state.documents[documentId];
+    if (!docState) {
       this.logger.warn(
         "SelectionPlugin",
-        "MissingDependency",
-        "Interaction manager plugin not loaded, text selection disabled"
+        "RegisterFailed",
+        `Cannot register selection on page ${pageIndex} for document ${documentId}: document state not initialized.`
       );
       return () => {
       };
     }
-    const { pageIndex, onRectsChange } = opts;
-    this.pageCallbacks.set(pageIndex, onRectsChange);
-    const geoTask = this.getOrLoadGeometry(pageIndex);
+    (_a = this.pageCallbacks.get(documentId)) == null ? void 0 : _a.set(pageIndex, onRectsChange);
+    const geoTask = this.getOrLoadGeometry(documentId, pageIndex);
+    const interactionScope = this.interactionManagerCapability.forDocument(documentId);
+    const enabledModes = this.enabledModesPerDoc.get(documentId);
     onRectsChange({
-      rects: selectRectsForPage(this.state, pageIndex),
-      boundingRect: selectBoundingRectForPage(this.state, pageIndex)
+      rects: selectRectsForPage(docState, pageIndex),
+      boundingRect: selectBoundingRectForPage(docState, pageIndex)
     });
     const handlers = {
       onPointerDown: (point, _evt, modeId) => {
-        if (!this.enabledModes.has(modeId)) return;
-        this.clearSelection();
-        const cached = this.state.geometry[pageIndex];
+        if (!(enabledModes == null ? void 0 : enabledModes.has(modeId))) return;
+        this.clearSelection(documentId);
+        const cached = this.getDocumentState(documentId).geometry[pageIndex];
         if (cached) {
           const g = glyphAt(cached, point);
           if (g !== -1) {
-            this.beginSelection(pageIndex, g);
+            this.beginSelection(documentId, pageIndex, g);
           }
         }
       },
       onPointerMove: (point, _evt, modeId) => {
-        var _a, _b;
-        if (!this.enabledModes.has(modeId)) return;
-        const cached = this.state.geometry[pageIndex];
+        if (!(enabledModes == null ? void 0 : enabledModes.has(modeId))) return;
+        const cached = this.getDocumentState(documentId).geometry[pageIndex];
         if (cached) {
           const g = glyphAt(cached, point);
           if (g !== -1) {
-            (_a = this.interactionManagerCapability) == null ? void 0 : _a.setCursor("selection-text", "text", 10);
+            interactionScope.setCursor("selection-text", "text", 10);
           } else {
-            (_b = this.interactionManagerCapability) == null ? void 0 : _b.removeCursor("selection-text");
+            interactionScope.removeCursor("selection-text");
           }
-          if (this.selecting && g !== -1) {
-            this.updateSelection(pageIndex, g);
+          if (this.selecting.get(documentId) && g !== -1) {
+            this.updateSelection(documentId, pageIndex, g);
           }
         }
       },
       onPointerUp: (_point, _evt, modeId) => {
-        if (!this.enabledModes.has(modeId)) return;
-        this.endSelection();
+        if (!(enabledModes == null ? void 0 : enabledModes.has(modeId))) return;
+        this.endSelection(documentId);
       },
       onHandlerActiveEnd: (modeId) => {
-        if (!this.enabledModes.has(modeId)) return;
-        this.clearSelection();
+        if (!(enabledModes == null ? void 0 : enabledModes.has(modeId))) return;
+        this.clearSelection(documentId);
       }
     };
     const unregisterHandlers = this.interactionManagerCapability.registerAlways({
-      scope: { type: "page", pageIndex },
+      scope: { type: "page", documentId, pageIndex },
       handlers
     });
     return () => {
+      var _a2;
       unregisterHandlers();
-      this.pageCallbacks.delete(pageIndex);
+      (_a2 = this.pageCallbacks.get(documentId)) == null ? void 0 : _a2.delete(pageIndex);
       geoTask.abort({ code: PdfErrorCode.Cancelled, message: "Cleanup" });
     };
   }
-  notifyPage(pageIndex) {
+  /**
+   * Helper to calculate viewport relative metrics for a page rect.
+   * Returns null if the rect cannot be converted to viewport space.
+   */
+  getPlacementMetrics(documentId, pageIndex, rect, vpMetrics) {
     var _a;
-    const callback = this.pageCallbacks.get(pageIndex);
+    const scrollScope = (_a = this.scrollCapability) == null ? void 0 : _a.forDocument(documentId);
+    const viewportRect = scrollScope == null ? void 0 : scrollScope.getRectPositionForPage(pageIndex, rect);
+    if (!viewportRect) return null;
+    const rectTopInView = viewportRect.origin.y - vpMetrics.scrollTop;
+    const rectBottomInView = viewportRect.origin.y + viewportRect.size.height - vpMetrics.scrollTop;
+    return {
+      pageIndex,
+      rect,
+      // Original Page Rect
+      spaceAbove: rectTopInView,
+      spaceBelow: vpMetrics.clientHeight - rectBottomInView,
+      isBottomVisible: rectBottomInView > 0 && rectBottomInView <= vpMetrics.clientHeight,
+      isTopVisible: rectTopInView >= 0 && rectTopInView < vpMetrics.clientHeight
+    };
+  }
+  recalculateMenuPlacement(documentId) {
+    const docState = this.state.documents[documentId];
+    if (!docState) return;
+    if (docState.selecting || docState.selection === null) {
+      this.menuPlacement$.emit(documentId, null);
+      return;
+    }
+    const bounds = selectBoundingRectsForAllPages(docState);
+    if (bounds.length === 0) {
+      this.menuPlacement$.emit(documentId, null);
+      return;
+    }
+    const tail = bounds[bounds.length - 1];
+    if (!this.viewportCapability || !this.scrollCapability) {
+      this.menuPlacement$.emit(documentId, {
+        pageIndex: tail.page,
+        rect: tail.rect,
+        spaceAbove: 0,
+        spaceBelow: Infinity,
+        // Pretend we have infinite space below to prevent auto-flipping
+        suggestTop: false,
+        isVisible: true
+        // Assume visible
+      });
+      return;
+    }
+    const viewportScope = this.viewportCapability.forDocument(documentId);
+    const vpMetrics = viewportScope.getMetrics();
+    const MENU_HEIGHT_GUESS = 40;
+    const head = bounds[0];
+    const tailMetrics = this.getPlacementMetrics(documentId, tail.page, tail.rect, vpMetrics);
+    const headMetrics = this.getPlacementMetrics(documentId, head.page, head.rect, vpMetrics);
+    if (tailMetrics) {
+      if (tailMetrics.isBottomVisible && tailMetrics.spaceBelow > MENU_HEIGHT_GUESS) {
+        this.menuPlacement$.emit(documentId, {
+          ...tailMetrics,
+          suggestTop: false,
+          isVisible: true
+        });
+        return;
+      }
+    }
+    if (headMetrics) {
+      if (headMetrics.isTopVisible) {
+        this.menuPlacement$.emit(documentId, {
+          ...headMetrics,
+          suggestTop: true,
+          isVisible: true
+        });
+        return;
+      }
+    }
+    if (tailMetrics && tailMetrics.isBottomVisible) {
+      this.menuPlacement$.emit(documentId, {
+        ...tailMetrics,
+        suggestTop: false,
+        isVisible: true
+      });
+      return;
+    }
+    this.menuPlacement$.emit(documentId, null);
+  }
+  notifyPage(documentId, pageIndex) {
+    var _a;
+    const callback = (_a = this.pageCallbacks.get(documentId)) == null ? void 0 : _a.get(pageIndex);
     if (callback) {
-      const mode = (_a = this.interactionManagerCapability) == null ? void 0 : _a.getActiveMode();
+      const docState = this.getDocumentState(documentId);
+      const mode = this.interactionManagerCapability.forDocument(documentId).getActiveMode();
       if (mode === "pointerMode") {
         callback({
-          rects: selectRectsForPage(this.state, pageIndex),
-          boundingRect: selectBoundingRectForPage(this.state, pageIndex)
+          rects: selectRectsForPage(docState, pageIndex),
+          boundingRect: selectBoundingRectForPage(docState, pageIndex)
         });
       } else {
         callback({ rects: [], boundingRect: null });
       }
     }
   }
-  notifyAllPages() {
-    this.pageCallbacks.forEach((_, pageIndex) => {
-      this.notifyPage(pageIndex);
+  notifyAllPages(documentId) {
+    var _a;
+    (_a = this.pageCallbacks.get(documentId)) == null ? void 0 : _a.forEach((_, pageIndex) => {
+      this.notifyPage(documentId, pageIndex);
     });
   }
-  getNewPageGeometryAndCache(pageIdx) {
-    if (!this.coreState.core.document)
+  getNewPageGeometryAndCache(documentId, pageIdx) {
+    const coreDoc = this.getCoreDocument(documentId);
+    if (!coreDoc || !coreDoc.document)
       return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Doc Not Found" });
-    const page = this.coreState.core.document.pages.find((p) => p.index === pageIdx);
-    const task = this.engine.getPageGeometry(this.coreState.core.document, page);
+    const page = coreDoc.document.pages.find((p) => p.index === pageIdx);
+    const task = this.engine.getPageGeometry(coreDoc.document, page);
     task.wait((geo) => {
-      this.dispatch(cachePageGeometry(pageIdx, geo));
+      this.dispatch(cachePageGeometry(documentId, pageIdx, geo));
     }, ignore);
     return task;
   }
   /* ── geometry cache ───────────────────────────────────── */
-  getOrLoadGeometry(pageIdx) {
-    const cached = this.state.geometry[pageIdx];
+  getOrLoadGeometry(documentId, pageIdx) {
+    const cached = this.getDocumentState(documentId).geometry[pageIdx];
     if (cached) return PdfTaskHelper.resolve(cached);
-    return this.getNewPageGeometryAndCache(pageIdx);
+    return this.getNewPageGeometryAndCache(documentId, pageIdx);
   }
   /* ── selection state updates ───────────────────────────── */
-  beginSelection(page, index) {
-    this.selecting = true;
-    this.anchor = { page, index };
-    this.dispatch(startSelection());
-    this.beginSelection$.emit({ page, index });
-  }
-  endSelection() {
-    this.selecting = false;
-    this.anchor = void 0;
-    this.dispatch(endSelection());
-    this.endSelection$.emit();
-  }
-  clearSelection() {
-    this.selecting = false;
-    this.anchor = void 0;
-    this.dispatch(clearSelection());
-    this.selChange$.emit(null);
-    this.notifyAllPages();
-  }
-  updateSelection(page, index) {
-    if (!this.selecting || !this.anchor) return;
-    const a = this.anchor;
+  beginSelection(documentId, page, index) {
+    this.selecting.set(documentId, true);
+    this.anchor.set(documentId, { page, index });
+    this.dispatch(startSelection(documentId));
+    this.beginSelection$.emit(documentId, { page, index });
+    this.recalculateMenuPlacement(documentId);
+  }
+  endSelection(documentId) {
+    this.selecting.set(documentId, false);
+    this.anchor.set(documentId, void 0);
+    this.dispatch(endSelection(documentId));
+    this.endSelection$.emit(documentId);
+    this.recalculateMenuPlacement(documentId);
+  }
+  clearSelection(documentId) {
+    this.selecting.set(documentId, false);
+    this.anchor.set(documentId, void 0);
+    this.dispatch(clearSelection(documentId));
+    this.selChange$.emit(documentId, null);
+    this.menuPlacement$.emit(documentId, null);
+    this.notifyAllPages(documentId);
+  }
+  updateSelection(documentId, page, index) {
+    if (!this.selecting.get(documentId) || !this.anchor.get(documentId)) return;
+    const a = this.anchor.get(documentId);
     const forward = page > a.page || page === a.page && index >= a.index;
     const start = forward ? a : { page, index };
     const end = forward ? { page, index } : a;
     const range = { start, end };
-    this.dispatch(setSelection(range));
-    this.updateRectsAndSlices(range);
-    this.selChange$.emit(range);
+    this.dispatch(setSelection(documentId, range));
+    this.updateRectsAndSlices(documentId, range);
+    this.selChange$.emit(documentId, range);
     for (let p = range.start.page; p <= range.end.page; p++) {
-      this.notifyPage(p);
+      this.notifyPage(documentId, p);
     }
   }
-  updateRectsAndSlices(range) {
+  updateRectsAndSlices(documentId, range) {
+    const docState = this.getDocumentState(documentId);
     const allRects = {};
     const allSlices = {};
     for (let p = range.start.page; p <= range.end.page; p++) {
-      const geo = this.state.geometry[p];
+      const geo = docState.geometry[p];
       const sb = sliceBounds(range, geo, p);
       if (!sb) continue;
       allRects[p] = rectsWithinSlice(geo, sb.from, sb.to);
       allSlices[p] = { start: sb.from, count: sb.to - sb.from + 1 };
     }
-    this.dispatch(setRects(allRects));
-    this.dispatch(setSlices(allSlices));
+    this.dispatch(setRects(documentId, allRects));
+    this.dispatch(setSlices(documentId, allSlices));
   }
-  getSelectedText() {
-    if (!this.coreState.core.document || !this.state.selection) {
+  getSelectedText(documentId) {
+    const coreDoc = this.getCoreDocument(documentId);
+    const docState = this.getDocumentState(documentId);
+    if (!(coreDoc == null ? void 0 : coreDoc.document) || !docState.selection) {
       return PdfTaskHelper.reject({
         code: PdfErrorCode.NotFound,
         message: "Doc Not Found or No Selection"
       });
     }
-    const sel = this.state.selection;
+    const sel = docState.selection;
     const req = [];
     for (let p = sel.start.page; p <= sel.end.page; p++) {
-      const s = this.state.slices[p];
+      const s = docState.slices[p];
       if (s) req.push({ pageIndex: p, charIndex: s.start, charCount: s.count });
     }
     if (req.length === 0) return PdfTaskHelper.resolve([]);
-    const task = this.engine.getTextSlices(this.coreState.core.document, req);
+    const task = this.engine.getTextSlices(coreDoc.document, req);
     task.wait((text) => {
-      this.textRetrieved$.emit(text);
+      this.textRetrieved$.emit(documentId, text);
     }, ignore);
     return task;
   }
-  copyToClipboard() {
-    const text = this.getSelectedText();
+  copyToClipboard(documentId) {
+    const text = this.getSelectedText(documentId);
     text.wait((text2) => {
-      this.copyToClipboard$.emit(text2.join("\n"));
+      this.copyToClipboard$.emit(documentId, text2.join("\n"));
     }, ignore);
   }
 };
 _SelectionPlugin.id = "selection";
 let SelectionPlugin = _SelectionPlugin;
-const initialState = {
-  geometry: {},
-  rects: {},
-  slices: {},
-  selection: null,
-  active: false,
-  selecting: false
-};
-const selectionReducer = (state = initialState, action) => {
-  switch (action.type) {
-    case CACHE_PAGE_GEOMETRY: {
-      const { page, geo } = action.payload;
-      return { ...state, geometry: { ...state.geometry, [page]: geo } };
-    }
-    case SET_SELECTION:
-      return { ...state, selection: action.payload, active: true };
-    case START_SELECTION:
-      return { ...state, selecting: true, selection: null, rects: {} };
-    case END_SELECTION:
-      return { ...state, selecting: false };
-    case CLEAR_SELECTION:
-      return { ...state, selecting: false, selection: null, rects: {}, active: false };
-    case SET_RECTS:
-      return { ...state, rects: action.payload };
-    case SET_SLICES:
-      return { ...state, slices: action.payload };
-    case RESET:
-      return initialState;
-    default:
-      return state;
-  }
-};
 const SelectionPluginPackage = {
   manifest,
   create: (registry) => new SelectionPlugin(SELECTION_PLUGIN_ID, registry),