@embedpdf/plugin-annotation 1.0.6 → 1.0.7

package/dist/index.js

@@ -5,104 +5,143 @@ var manifest = {
   name: "Annotation Plugin",
   version: "1.0.0",
   provides: ["annotation"],
-  requires: [],
-  optional: [],
+  requires: ["interaction-manager", "selection"],
+  optional: ["history"],
   defaultConfig: {
-    enabled: true
+    enabled: true,
+    autoCommit: true
   }
 };
 
 // src/lib/annotation-plugin.ts
-import { BasePlugin, createBehaviorEmitter, SET_DOCUMENT } from "@embedpdf/core";
-
-// ../models/dist/index.js
-var PdfSoftHyphenMarker = "\xAD";
-var PdfZeroWidthSpace = "\u200B";
-var PdfWordJoiner = "\u2060";
-var PdfBomOrZwnbsp = "\uFEFF";
-var PdfNonCharacterFFFE = "\uFFFE";
-var PdfNonCharacterFFFF = "\uFFFF";
-var PdfUnwantedTextMarkers = Object.freeze([
-  PdfSoftHyphenMarker,
-  PdfZeroWidthSpace,
-  PdfWordJoiner,
-  PdfBomOrZwnbsp,
-  PdfNonCharacterFFFE,
-  PdfNonCharacterFFFF
-]);
-var PdfUnwantedTextRegex = new RegExp(`[${PdfUnwantedTextMarkers.join("")}]`, "g");
-var PdfAnnotationSubtype = /* @__PURE__ */ ((PdfAnnotationSubtype2) => {
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["UNKNOWN"] = 0] = "UNKNOWN";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["TEXT"] = 1] = "TEXT";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["LINK"] = 2] = "LINK";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["FREETEXT"] = 3] = "FREETEXT";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["LINE"] = 4] = "LINE";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["SQUARE"] = 5] = "SQUARE";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["CIRCLE"] = 6] = "CIRCLE";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["POLYGON"] = 7] = "POLYGON";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["POLYLINE"] = 8] = "POLYLINE";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["HIGHLIGHT"] = 9] = "HIGHLIGHT";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["UNDERLINE"] = 10] = "UNDERLINE";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["SQUIGGLY"] = 11] = "SQUIGGLY";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["STRIKEOUT"] = 12] = "STRIKEOUT";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["STAMP"] = 13] = "STAMP";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["CARET"] = 14] = "CARET";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["INK"] = 15] = "INK";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["POPUP"] = 16] = "POPUP";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["FILEATTACHMENT"] = 17] = "FILEATTACHMENT";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["SOUND"] = 18] = "SOUND";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["MOVIE"] = 19] = "MOVIE";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["WIDGET"] = 20] = "WIDGET";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["SCREEN"] = 21] = "SCREEN";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["PRINTERMARK"] = 22] = "PRINTERMARK";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["TRAPNET"] = 23] = "TRAPNET";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["WATERMARK"] = 24] = "WATERMARK";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["THREED"] = 25] = "THREED";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["RICHMEDIA"] = 26] = "RICHMEDIA";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["XFAWIDGET"] = 27] = "XFAWIDGET";
-  PdfAnnotationSubtype2[PdfAnnotationSubtype2["REDACT"] = 28] = "REDACT";
-  return PdfAnnotationSubtype2;
-})(PdfAnnotationSubtype || {});
-function ignore() {
-}
+import {
+  BasePlugin,
+  createBehaviorEmitter,
+  enumEntries,
+  SET_DOCUMENT
+} from "@embedpdf/core";
+import {
+  ignore,
+  Task,
+  PdfAnnotationSubtype,
+  PdfTaskHelper,
+  PdfErrorCode
+} from "@embedpdf/models";
 
 // src/lib/actions.ts
-var SET_ANNOTATIONS = "SET_ANNOTATIONS";
-var SELECT_ANNOTATION = "SELECT_ANNOTATION";
-var DESELECT_ANNOTATION = "DESELECT_ANNOTATION";
-var SET_ANNOTATION_MODE = "SET_ANNOTATION_MODE";
-var UPDATE_ANNOTATION_COLOR = "UPDATE_ANNOTATION_COLOR";
-function setAnnotations(payload) {
-  return { type: SET_ANNOTATIONS, payload };
-}
-function selectAnnotation(pageIndex, annotationId, annotation) {
-  return {
-    type: SELECT_ANNOTATION,
-    payload: { pageIndex, annotationId, annotation }
-  };
-}
-function deselectAnnotation() {
-  return { type: DESELECT_ANNOTATION };
-}
-function setAnnotationMode(mode) {
-  return {
-    type: SET_ANNOTATION_MODE,
-    payload: mode
-  };
-}
-function updateAnnotationColor(pageIndex, annotationId, color) {
-  return {
-    type: UPDATE_ANNOTATION_COLOR,
-    payload: { pageIndex, annotationId, color }
-  };
-}
+var SET_ANNOTATIONS = "ANNOTATION/SET_ANNOTATIONS";
+var REINDEX_PAGE_ANNOTATIONS = "ANNOTATION/REINDEX_PAGE";
+var SELECT_ANNOTATION = "ANNOTATION/SELECT_ANNOTATION";
+var DESELECT_ANNOTATION = "ANNOTATION/DESELECT_ANNOTATION";
+var SET_ANNOTATION_MODE = "ANNOTATION/SET_ANNOTATION_MODE";
+var UPDATE_TOOL_DEFAULTS = "ANNOTATION/UPDATE_TOOL_DEFAULTS";
+var ADD_COLOR_PRESET = "ANNOTATION/ADD_COLOR_PRESET";
+var CREATE_ANNOTATION = "ANNOTATION/CREATE_ANNOTATION";
+var PATCH_ANNOTATION = "ANNOTATION/PATCH_ANNOTATION";
+var DELETE_ANNOTATION = "ANNOTATION/DELETE_ANNOTATION";
+var COMMIT_PENDING_CHANGES = "ANNOTATION/COMMIT";
+var STORE_PDF_ID = "ANNOTATION/STORE_PDF_ID";
+var PURGE_ANNOTATION = "ANNOTATION/PURGE_ANNOTATION";
+var setAnnotations = (p) => ({
+  type: SET_ANNOTATIONS,
+  payload: p
+});
+var reindexPageAnnotations = (pageIndex) => ({
+  type: REINDEX_PAGE_ANNOTATIONS,
+  payload: { pageIndex }
+});
+var selectAnnotation = (pageIndex, localId) => ({
+  type: SELECT_ANNOTATION,
+  payload: { pageIndex, localId }
+});
+var deselectAnnotation = () => ({ type: DESELECT_ANNOTATION });
+var setAnnotationMode = (m) => ({
+  type: SET_ANNOTATION_MODE,
+  payload: m
+});
+var updateToolDefaults = (subtype, patch) => ({ type: UPDATE_TOOL_DEFAULTS, payload: { subtype, patch } });
+var addColorPreset = (c) => ({
+  type: ADD_COLOR_PRESET,
+  payload: c
+});
+var createAnnotation = (pageIndex, localId, annotation) => ({
+  type: CREATE_ANNOTATION,
+  payload: { pageIndex, localId, annotation }
+});
+var patchAnnotation = (pageIndex, localId, patch) => ({
+  type: PATCH_ANNOTATION,
+  payload: { pageIndex, localId, patch }
+});
+var deleteAnnotation = (pageIndex, localId) => ({
+  type: DELETE_ANNOTATION,
+  payload: { pageIndex, localId }
+});
+var commitPendingChanges = () => ({ type: COMMIT_PENDING_CHANGES });
+var storePdfId = (uid, pdfId) => ({
+  type: STORE_PDF_ID,
+  payload: { uid, pdfId }
+});
+var purgeAnnotation = (uid) => ({
+  type: PURGE_ANNOTATION,
+  payload: { uid }
+});
+
+// src/lib/utils.ts
+var makeUid = (pageIndex, localId) => `p${pageIndex}#${localId}`;
+var parseUid = (uid) => {
+  const [pg, rest] = uid.slice(1).split("#");
+  return { pageIndex: Number(pg), localId: Number(rest) };
+};
+
+// src/lib/selectors.ts
+var makeUid2 = (page, id) => `p${page}#${id}`;
+var getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
+var getAnnotations = (s) => {
+  const out = {};
+  for (const p of Object.keys(s.pages).map(Number)) out[p] = getAnnotationsByPageIndex(s, p);
+  return out;
+};
+var getSelectedAnnotation = (s) => s.selectedUid ? s.byUid[s.selectedUid] : null;
+var getSelectedAnnotationWithPageIndex = (s) => {
+  if (!s.selectedUid) return null;
+  const { pageIndex, localId } = parseUid(s.selectedUid);
+  return { pageIndex, localId, annotation: s.byUid[s.selectedUid].object };
+};
+var getSelectedAnnotationByPageIndex = (s, pageIndex) => {
+  if (!s.selectedUid) return null;
+  const pageUids = s.pages[pageIndex] ?? [];
+  if (pageUids.includes(s.selectedUid)) {
+    return s.byUid[s.selectedUid];
+  }
+  return null;
+};
+var isInAnnotationMode = (s) => s.annotationMode !== null;
+var getSelectedAnnotationMode = (s) => s.annotationMode;
+var isAnnotationSelected = (s, page, id) => s.selectedUid === makeUid2(page, id);
 
 // src/lib/annotation-plugin.ts
 var AnnotationPlugin = class extends BasePlugin {
-  constructor(id, registry, engine) {
+  constructor(id, registry, engine, config) {
     super(id, registry);
+    this.ANNOTATION_HISTORY_TOPIC = "annotations";
     this.state$ = createBehaviorEmitter();
+    /** Map <subtype> → <modeId>.  Filled once in `initialize()`. */
+    this.modeBySubtype = /* @__PURE__ */ new Map();
+    /** The inverse map for quick lookup in onModeChange().          */
+    this.subtypeByMode = /* @__PURE__ */ new Map();
+    this.modeChange$ = createBehaviorEmitter();
+    this.activeTool$ = createBehaviorEmitter({
+      mode: null,
+      defaults: null
+    });
     this.engine = engine;
+    this.config = config;
+    const selection = registry.getPlugin("selection");
+    this.selection = selection?.provides() ?? null;
+    const history = registry.getPlugin("history");
+    this.history = history?.provides() ?? null;
+    const interactionManager = registry.getPlugin("interaction-manager");
+    this.interactionManager = interactionManager?.provides() ?? null;
     this.coreStore.onAction(SET_DOCUMENT, (_action, state) => {
       const doc = state.core.document;
       if (doc) {
@@ -111,29 +150,119 @@ var AnnotationPlugin = class extends BasePlugin {
     });
   }
   async initialize() {
+    for (const [subtype, defaults] of enumEntries(this.state.toolDefaults)) {
+      this.registerTool(subtype, defaults);
+    }
+    this.history?.onHistoryChange((topic) => {
+      if (topic === this.ANNOTATION_HISTORY_TOPIC && this.config.autoCommit !== false) {
+        this.commit();
+      }
+    });
+    this.interactionManager?.onModeChange((s) => {
+      const newSubtype = this.subtypeByMode.get(s.activeMode) ?? null;
+      if (newSubtype !== this.state.annotationMode) {
+        this.dispatch(setAnnotationMode(newSubtype));
+        this.modeChange$.emit(newSubtype);
+      }
+    });
+    this.selection?.onEndSelection(() => {
+      if (!this.state.annotationMode) return;
+      const formattedSelection = this.selection?.getFormattedSelection();
+      if (!formattedSelection) return;
+      for (const selection of formattedSelection) {
+        const rect = selection.rect;
+        const segmentRects = selection.segmentRects;
+        const type = this.state.annotationMode;
+        const color = this.state.toolDefaults[type].color;
+        const opacity = this.state.toolDefaults[type].opacity;
+        this.createAnnotation(selection.pageIndex, {
+          type,
+          rect,
+          segmentRects,
+          color,
+          opacity,
+          pageIndex: selection.pageIndex,
+          id: Date.now() + Math.random()
+        });
+      }
+      this.selection?.clear();
+    });
+  }
+  registerTool(subtype, defaults) {
+    const modeId = defaults.interaction.mode;
+    const interactionMode = {
+      id: modeId,
+      scope: "page",
+      exclusive: defaults.interaction.exclusive,
+      cursor: defaults.interaction.cursor
+    };
+    this.interactionManager?.registerMode(interactionMode);
+    if (defaults.textSelection) {
+      this.selection?.enableForMode(modeId);
+    }
+    this.modeBySubtype.set(subtype, modeId);
+    this.subtypeByMode.set(modeId, subtype);
   }
   buildCapability() {
     return {
       getPageAnnotations: (options) => {
         return this.getPageAnnotations(options);
       },
+      getSelectedAnnotation: () => {
+        return getSelectedAnnotation(this.state);
+      },
       selectAnnotation: (pageIndex, annotationId) => {
         this.selectAnnotation(pageIndex, annotationId);
       },
       deselectAnnotation: () => {
         this.dispatch(deselectAnnotation());
       },
-      updateAnnotationColor: async (color) => {
-        return this.updateSelectedAnnotationColor(color);
+      getAnnotationMode: () => {
+        return this.state.annotationMode;
+      },
+      setAnnotationMode: (subtype) => {
+        if (subtype === this.state.annotationMode) return;
+        if (subtype) {
+          const mode = this.modeBySubtype.get(subtype);
+          if (!mode) throw new Error(`Mode missing for subtype ${subtype}`);
+          this.interactionManager?.activate(mode);
+        } else {
+          this.interactionManager?.activate("default");
+        }
+      },
+      getToolDefaults: (subtype) => {
+        const defaults = this.state.toolDefaults[subtype];
+        if (!defaults) {
+          throw new Error(`No defaults found for subtype: ${subtype}`);
+        }
+        return defaults;
       },
-      setAnnotationMode: (mode) => {
-        this.dispatch(setAnnotationMode(mode));
+      setToolDefaults: (subtype, patch) => {
+        this.dispatch(updateToolDefaults(subtype, patch));
       },
-      onStateChange: this.state$.on
+      getColorPresets: () => [...this.state.colorPresets],
+      addColorPreset: (color) => this.dispatch(addColorPreset(color)),
+      createAnnotation: (pageIndex, annotation) => this.createAnnotation(pageIndex, annotation),
+      updateAnnotation: (pageIndex, localId, patch) => this.updateAnnotation(pageIndex, localId, patch),
+      deleteAnnotation: (pageIndex, localId) => this.deleteAnnotation(pageIndex, localId),
+      onStateChange: this.state$.on,
+      onModeChange: this.modeChange$.on,
+      onActiveToolChange: this.activeTool$.on,
+      commit: () => this.commit()
     };
   }
-  onStoreUpdated(_prevState, newState) {
-    this.state$.emit(newState);
+  emitActiveTool(state) {
+    const mode = state.annotationMode;
+    this.activeTool$.emit({
+      mode,
+      defaults: mode ? state.toolDefaults[mode] : null
+    });
+  }
+  onStoreUpdated(prev, next) {
+    this.state$.emit(next);
+    if (prev.annotationMode !== next.annotationMode || prev.toolDefaults[prev.annotationMode ?? PdfAnnotationSubtype.HIGHLIGHT] !== next.toolDefaults[next.annotationMode ?? PdfAnnotationSubtype.HIGHLIGHT]) {
+      this.emitActiveTool(next);
+    }
   }
   getAllAnnotations(doc) {
     const task = this.engine.getAllAnnotations(doc);
@@ -143,114 +272,328 @@ var AnnotationPlugin = class extends BasePlugin {
     const { pageIndex } = options;
     const doc = this.coreState.core.document;
     if (!doc) {
-      throw new Error("document does not open");
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
     }
     const page = doc.pages.find((p) => p.index === pageIndex);
     if (!page) {
-      throw new Error("page does not open");
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Page not found" });
     }
     return this.engine.getPageAnnotations(doc, page);
   }
   selectAnnotation(pageIndex, annotationId) {
-    const pageAnnotations = this.state.annotations[pageIndex];
-    if (!pageAnnotations) {
+    this.dispatch(selectAnnotation(pageIndex, annotationId));
+  }
+  createAnnotation(pageIndex, annotation) {
+    const localId = annotation.id;
+    const execute = () => this.dispatch(createAnnotation(pageIndex, localId, annotation));
+    if (!this.history) {
+      execute();
+      if (this.config.autoCommit) this.commit();
       return;
     }
-    const annotation = pageAnnotations.find((a) => a.id === annotationId);
-    if (annotation) {
-      this.dispatch(selectAnnotation(pageIndex, annotationId, annotation));
-    }
+    const command = {
+      execute,
+      undo: () => {
+        this.dispatch(deselectAnnotation());
+        this.dispatch(deleteAnnotation(pageIndex, localId));
+      }
+    };
+    this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
-  async updateSelectedAnnotationColor(color) {
-    const selected = this.state.selectedAnnotation;
-    if (!selected) {
-      return false;
+  updateAnnotation(pageIndex, localId, patch) {
+    if (!this.history) {
+      this.dispatch(patchAnnotation(pageIndex, localId, patch));
+      if (this.config.autoCommit !== false) {
+        this.commit();
+      }
+      return;
     }
-    if (selected.annotation.type !== PdfAnnotationSubtype.HIGHLIGHT) {
-      return false;
+    const originalObject = this.state.byUid[makeUid(pageIndex, localId)].object;
+    const originalPatch = Object.fromEntries(
+      Object.keys(patch).map((key) => [key, originalObject[key]])
+    );
+    const command = {
+      execute: () => this.dispatch(patchAnnotation(pageIndex, localId, patch)),
+      undo: () => this.dispatch(patchAnnotation(pageIndex, localId, originalPatch))
+    };
+    this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
+  }
+  deleteAnnotation(pageIndex, localId) {
+    if (!this.history) {
+      this.dispatch(deselectAnnotation());
+      this.dispatch(deleteAnnotation(pageIndex, localId));
+      if (this.config.autoCommit !== false) {
+        this.commit();
+      }
+      return;
     }
+    const originalAnnotation = this.state.byUid[makeUid(pageIndex, localId)].object;
+    const command = {
+      execute: () => {
+        this.dispatch(deselectAnnotation());
+        this.dispatch(deleteAnnotation(pageIndex, localId));
+      },
+      undo: () => this.dispatch(createAnnotation(pageIndex, localId, originalAnnotation))
+    };
+    this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
+  }
+  commit() {
+    const task = new Task();
+    if (!this.state.hasPendingChanges) return PdfTaskHelper.resolve(true);
     const doc = this.coreState.core.document;
-    if (!doc) {
-      return false;
+    if (!doc)
+      return PdfTaskHelper.reject({ code: PdfErrorCode.NotFound, message: "Document not found" });
+    const creations = [];
+    const updates = [];
+    const deletionsByPage = /* @__PURE__ */ new Map();
+    const affectedPages = /* @__PURE__ */ new Set();
+    for (const [uid, ta] of Object.entries(this.state.byUid)) {
+      if (ta.commitState === "synced") continue;
+      const { pageIndex } = parseUid(uid);
+      const page = doc.pages.find((p) => p.index === pageIndex);
+      if (!page) continue;
+      affectedPages.add(pageIndex);
+      switch (ta.commitState) {
+        case "new":
+          const task2 = this.engine.createPageAnnotation(doc, page, ta.object);
+          task2.wait((annoId) => this.dispatch(storePdfId(uid, annoId)), ignore);
+          creations.push(task2);
+          break;
+        case "dirty":
+          updates.push(
+            this.engine.updatePageAnnotation(doc, page, { ...ta.object, id: ta.pdfId })
+          );
+          break;
+        case "deleted":
+          if (!deletionsByPage.has(pageIndex)) {
+            deletionsByPage.set(pageIndex, []);
+          }
+          deletionsByPage.get(pageIndex).push({ ta, uid });
+          break;
+      }
     }
-    this.dispatch(updateAnnotationColor(selected.pageIndex, selected.annotationId, color));
-    try {
-      return true;
-    } catch (error) {
-      console.error("Failed to update annotation color:", error);
-      return false;
+    const deletionTasks = [];
+    for (const [pageIndex, deletions] of deletionsByPage.entries()) {
+      const page = doc.pages.find((p) => p.index === pageIndex);
+      deletions.sort((a, b) => (b.ta.pdfId ?? -1) - (a.ta.pdfId ?? -1));
+      for (const { ta, uid } of deletions) {
+        if (ta.pdfId !== void 0) {
+          const task2 = new Task();
+          const removeTask = this.engine.removePageAnnotation(doc, page, {
+            ...ta.object,
+            id: ta.pdfId
+          });
+          removeTask.wait(() => {
+            this.dispatch(purgeAnnotation(uid));
+            task2.resolve(true);
+          }, task2.fail);
+          deletionTasks.push(task2);
+        } else {
+          this.dispatch(purgeAnnotation(uid));
+        }
+      }
     }
+    const allWriteTasks = [...creations, ...updates, ...deletionTasks];
+    Task.allSettled(allWriteTasks).wait(() => {
+      for (const pageIndex of affectedPages) {
+        this.dispatch(reindexPageAnnotations(pageIndex));
+      }
+      this.dispatch(commitPendingChanges());
+      task.resolve(true);
+    }, task.fail);
+    return task;
   }
 };
 AnnotationPlugin.id = "annotation";
 
 // src/lib/reducer.ts
-var initialState = {
-  annotations: {},
-  selectedAnnotation: null,
-  annotationMode: null
+import { PdfAnnotationSubtype as PdfAnnotationSubtype2 } from "@embedpdf/models";
+var DEFAULT_COLORS = [
+  "#E44234",
+  "#FF8D00",
+  "#FFCD45",
+  "#5CC96E",
+  "#25D2D1",
+  "#597CE2",
+  "#C544CE",
+  "#7D2E25"
+];
+var patchAnno = (state, uid, patch) => {
+  const prev = state.byUid[uid];
+  if (!prev) return state;
+  return {
+    ...state,
+    byUid: {
+      ...state.byUid,
+      [uid]: {
+        ...prev,
+        commitState: prev.commitState === "synced" ? "dirty" : prev.commitState,
+        object: { ...prev.object, ...patch }
+      }
+    },
+    hasPendingChanges: true
+  };
 };
+var initialState = (cfg) => ({
+  pages: {},
+  byUid: {},
+  selectedUid: null,
+  annotationMode: null,
+  toolDefaults: {
+    [PdfAnnotationSubtype2.HIGHLIGHT]: {
+      name: "Highlight",
+      color: "#FFCD45",
+      opacity: 1,
+      interaction: { mode: "highlight", exclusive: false },
+      textSelection: true
+    },
+    [PdfAnnotationSubtype2.UNDERLINE]: {
+      name: "Underline",
+      color: "#E44234",
+      opacity: 1,
+      interaction: { mode: "underline", exclusive: false },
+      textSelection: true
+    },
+    [PdfAnnotationSubtype2.STRIKEOUT]: {
+      name: "Strikeout",
+      color: "#E44234",
+      opacity: 1,
+      interaction: { mode: "strikeout", exclusive: false },
+      textSelection: true
+    },
+    [PdfAnnotationSubtype2.SQUIGGLY]: {
+      name: "Squiggly",
+      color: "#E44234",
+      opacity: 1,
+      interaction: { mode: "squiggly", exclusive: false },
+      textSelection: true
+    },
+    ...cfg.toolDefaults
+  },
+  colorPresets: cfg.colorPresets ?? DEFAULT_COLORS,
+  hasPendingChanges: false
+});
 var reducer = (state, action) => {
   switch (action.type) {
-    case SET_ANNOTATIONS:
+    /* ───── bulk load from engine ───── */
+    case SET_ANNOTATIONS: {
+      const newPages = { ...state.pages };
+      const newByUid = { ...state.byUid };
+      for (const [pgStr, list] of Object.entries(action.payload)) {
+        const pageIndex = Number(pgStr);
+        const oldUidsOnPage = state.pages[pageIndex] || [];
+        for (const uid of oldUidsOnPage) {
+          delete newByUid[uid];
+        }
+        const newUidsOnPage = list.map((a, index) => {
+          const localId = Date.now() + Math.random() + index;
+          const uid = makeUid(pageIndex, localId);
+          newByUid[uid] = { localId, pdfId: a.id, commitState: "synced", object: a };
+          return uid;
+        });
+        newPages[pageIndex] = newUidsOnPage;
+      }
+      return { ...state, pages: newPages, byUid: newByUid };
+    }
+    /* ───── GUI bits ───── */
+    case SET_ANNOTATION_MODE:
+      return { ...state, annotationMode: action.payload };
+    case SELECT_ANNOTATION:
       return {
         ...state,
-        annotations: action.payload,
-        // Clear selection if the annotations have changed
-        selectedAnnotation: null
+        selectedUid: makeUid(action.payload.pageIndex, action.payload.localId)
       };
-    case SELECT_ANNOTATION:
+    case DESELECT_ANNOTATION:
+      return { ...state, selectedUid: null };
+    case ADD_COLOR_PRESET:
+      return state.colorPresets.includes(action.payload) ? state : { ...state, colorPresets: [...state.colorPresets, action.payload] };
+    case UPDATE_TOOL_DEFAULTS: {
+      const { subtype, patch } = action.payload;
       return {
         ...state,
-        selectedAnnotation: action.payload
+        toolDefaults: {
+          ...state.toolDefaults,
+          [subtype]: { ...state.toolDefaults[subtype], ...patch }
+        }
       };
-    case DESELECT_ANNOTATION:
+    }
+    /* ───── create ───── */
+    case CREATE_ANNOTATION: {
+      const { pageIndex, localId, annotation } = action.payload;
+      const uid = makeUid(pageIndex, localId);
       return {
         ...state,
-        selectedAnnotation: null
+        pages: { ...state.pages, [pageIndex]: [...state.pages[pageIndex] ?? [], uid] },
+        byUid: {
+          ...state.byUid,
+          [uid]: { localId, pdfId: void 0, commitState: "new", object: annotation }
+        },
+        hasPendingChanges: true
       };
-    case SET_ANNOTATION_MODE:
+    }
+    /* ───── delete ───── */
+    case DELETE_ANNOTATION: {
+      const { pageIndex, localId } = action.payload;
+      const uid = makeUid(pageIndex, localId);
+      if (!state.byUid[uid]) return state;
       return {
         ...state,
-        annotationMode: action.payload
+        pages: {
+          ...state.pages,
+          [pageIndex]: (state.pages[pageIndex] ?? []).filter((u) => u !== uid)
+        },
+        byUid: {
+          ...state.byUid,
+          [uid]: { ...state.byUid[uid], commitState: "deleted" }
+        },
+        hasPendingChanges: true
       };
-    case UPDATE_ANNOTATION_COLOR: {
-      const { pageIndex, annotationId, color } = action.payload;
-      const pageAnnotations = state.annotations[pageIndex];
-      if (!pageAnnotations) {
-        return state;
+    }
+    /* ───── field edits ───── */
+    case PATCH_ANNOTATION: {
+      const uid = makeUid(action.payload.pageIndex, action.payload.localId);
+      return patchAnno(state, uid, action.payload.patch);
+    }
+    /* ───── commit bookkeeping ───── */
+    case COMMIT_PENDING_CHANGES: {
+      const cleaned = {};
+      for (const [uid, ta] of Object.entries(state.byUid)) {
+        cleaned[uid] = {
+          ...ta,
+          commitState: ta.commitState === "dirty" || ta.commitState === "new" ? "synced" : ta.commitState
+        };
       }
-      const updatedAnnotations = pageAnnotations.map((annotation) => {
-        if (annotation.id === annotationId) {
-          if (annotation.type === PdfAnnotationSubtype.HIGHLIGHT) {
-            return {
-              ...annotation,
-              color
-            };
-          }
-        }
-        return annotation;
+      return { ...state, byUid: cleaned, hasPendingChanges: false };
+    }
+    case REINDEX_PAGE_ANNOTATIONS: {
+      const { pageIndex } = action.payload;
+      const newByUid = { ...state.byUid };
+      const uidsOnPage = state.pages[pageIndex] || [];
+      const annosOnPage = uidsOnPage.map((uid) => state.byUid[uid]).filter((ta) => ta && ta.commitState !== "deleted");
+      annosOnPage.sort((a, b) => (a.pdfId ?? Infinity) - (b.pdfId ?? Infinity));
+      annosOnPage.forEach((ta, newPdfId) => {
+        const uid = makeUid(pageIndex, ta.localId);
+        newByUid[uid] = { ...newByUid[uid], pdfId: newPdfId };
       });
-      const newAnnotations = {
-        ...state.annotations,
-        [pageIndex]: updatedAnnotations
-      };
-      let newSelectedAnnotation = state.selectedAnnotation;
-      if (newSelectedAnnotation && newSelectedAnnotation.pageIndex === pageIndex && newSelectedAnnotation.annotationId === annotationId) {
-        const updatedAnnotation = updatedAnnotations.find((a) => a.id === annotationId);
-        if (updatedAnnotation) {
-          newSelectedAnnotation = {
-            ...newSelectedAnnotation,
-            annotation: updatedAnnotation
-          };
-        }
-      }
+      return { ...state, byUid: newByUid };
+    }
+    case STORE_PDF_ID: {
+      const { uid, pdfId } = action.payload;
+      const ta = state.byUid[uid];
+      if (!ta) return state;
       return {
         ...state,
-        annotations: newAnnotations,
-        selectedAnnotation: newSelectedAnnotation
+        byUid: {
+          ...state.byUid,
+          [uid]: { ...ta, pdfId, commitState: "synced" }
+        }
       };
     }
+    case PURGE_ANNOTATION: {
+      const { uid } = action.payload;
+      const { [uid]: _gone, ...rest } = state.byUid;
+      return { ...state, byUid: rest };
+    }
     default:
       return state;
   }
@@ -259,14 +602,22 @@ var reducer = (state, action) => {
 // src/lib/index.ts
 var AnnotationPluginPackage = {
   manifest,
-  create: (registry, engine) => new AnnotationPlugin(ANNOTATION_PLUGIN_ID, registry, engine),
+  create: (registry, engine, config) => new AnnotationPlugin(ANNOTATION_PLUGIN_ID, registry, engine, config),
   reducer,
-  initialState
+  initialState: (_, config) => initialState(config)
 };
 export {
   ANNOTATION_PLUGIN_ID,
   AnnotationPlugin,
   AnnotationPluginPackage,
+  getAnnotations,
+  getAnnotationsByPageIndex,
+  getSelectedAnnotation,
+  getSelectedAnnotationByPageIndex,
+  getSelectedAnnotationMode,
+  getSelectedAnnotationWithPageIndex,
+  isAnnotationSelected,
+  isInAnnotationMode,
   manifest
 };
 //# sourceMappingURL=index.js.map