@embedpdf/plugin-annotation 1.0.12 → 1.0.14

package/dist/index.js

@@ -1,5 +1,5 @@
 import { BasePlugin, createBehaviorEmitter, SET_DOCUMENT } from "@embedpdf/core";
-import { PdfAnnotationSubtype, PdfBlendMode, ignore, PdfTaskHelper, PdfErrorCode, Rotation, AppearanceMode, Task } from "@embedpdf/models";
+import { PdfAnnotationLineEnding, rectFromPoints, expandRect, rotateAndTranslatePoint, PdfAnnotationSubtype, PdfBlendMode, ignore, PdfTaskHelper, PdfErrorCode, Rotation, AppearanceMode, Task, PdfVerticalAlignment, PdfTextAlignment, PdfStandardFont, PdfAnnotationBorderStyle } from "@embedpdf/models";
 const ANNOTATION_PLUGIN_ID = "annotation";
 const manifest = {
   id: ANNOTATION_PLUGIN_ID,
@@ -74,6 +74,12 @@ const parseUid = (uid) => {
   const [pg, rest] = uid.slice(1).split("#");
   return { pageIndex: Number(pg), localId: Number(rest) };
 };
+const makeVariantKey = (subtype, intent) => intent ? `${subtype}#${intent}` : `${subtype}`;
+const parseVariantKey = (key) => {
+  const [subStr, intent] = key.split("#");
+  return { subtype: Number(subStr), intent };
+};
+const variantKeyFromAnnotation = (a) => makeVariantKey(a.type, a.intent);
 const makeUid = (page, id) => `p${page}#${id}`;
 const getAnnotationsByPageIndex = (s, page) => (s.pages[page] ?? []).map((uid) => s.byUid[uid]);
 const getAnnotations = (s) => {
@@ -98,12 +104,268 @@ const getSelectedAnnotationByPageIndex = (s, pageIndex) => {
 const isInAnnotationVariant = (s) => s.activeVariant !== null;
 const getSelectedAnnotationVariant = (s) => s.activeVariant;
 const isAnnotationSelected = (s, page, id) => s.selectedUid === makeUid(page, id);
-const makeVariantKey = (subtype, intent) => intent ? `${subtype}#${intent}` : `${subtype}`;
-const parseVariantKey = (key) => {
-  const [subStr, intent] = key.split("#");
-  return { subtype: Number(subStr), intent };
+function getToolDefaultsBySubtypeAndIntent(state, subtype, intent) {
+  const variantKey = makeVariantKey(subtype, intent ?? void 0);
+  const fallbackKey = makeVariantKey(subtype);
+  const defaults = state.toolDefaults[variantKey] ?? state.toolDefaults[fallbackKey];
+  if (!defaults) {
+    throw new Error(
+      `No tool defaults found for subtype ${subtype}${intent ? ` and intent ${intent}` : ""}`
+    );
+  }
+  return defaults;
+}
+function createArrowHandler(isClosed) {
+  const calculateGeometry = (sw) => {
+    const len = sw * 9;
+    const a = Math.PI / 6;
+    return {
+      x: -len * Math.cos(a),
+      y: len * Math.sin(a)
+    };
+  };
+  return {
+    getSvgPath: (sw) => {
+      const { x, y } = calculateGeometry(sw);
+      return isClosed ? `M 0 0 L ${x} ${y} L ${x} ${-y} Z` : `M ${x} ${y} L 0 0 L ${x} ${-y}`;
+    },
+    getLocalPoints: (sw) => {
+      const { x, y } = calculateGeometry(sw);
+      return [
+        { x: 0, y: 0 },
+        { x, y },
+        { x, y: -y }
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    filled: isClosed
+  };
+}
+function createLineHandler(lengthFactor, rotationFn) {
+  const getHalfLength = (sw) => sw * lengthFactor / 2;
+  return {
+    getSvgPath: (sw) => {
+      const l = getHalfLength(sw);
+      return `M ${-l} 0 L ${l} 0`;
+    },
+    getLocalPoints: (sw) => {
+      const l = getHalfLength(sw);
+      return [
+        { x: -l, y: 0 },
+        { x: l, y: 0 }
+      ];
+    },
+    getRotation: rotationFn,
+    filled: false
+  };
+}
+const OpenArrowHandler = createArrowHandler(false);
+const ClosedArrowHandler = createArrowHandler(true);
+const LINE_ENDING_HANDLERS = {
+  [PdfAnnotationLineEnding.OpenArrow]: OpenArrowHandler,
+  [PdfAnnotationLineEnding.ClosedArrow]: ClosedArrowHandler,
+  [PdfAnnotationLineEnding.ROpenArrow]: {
+    ...OpenArrowHandler,
+    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  },
+  [PdfAnnotationLineEnding.RClosedArrow]: {
+    ...ClosedArrowHandler,
+    getRotation: (segmentAngle) => segmentAngle + Math.PI
+  },
+  [PdfAnnotationLineEnding.Circle]: {
+    getSvgPath: (sw) => {
+      const r = sw * 5 / 2;
+      return `M ${r} 0 A ${r} ${r} 0 1 1 ${-r} 0 A ${r} ${r} 0 1 1 ${r} 0`;
+    },
+    getLocalPoints: (sw) => {
+      const r = sw * 5 / 2;
+      return [
+        { x: -r, y: -r },
+        { x: r, y: r }
+      ];
+    },
+    getRotation: () => 0,
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Square]: {
+    getSvgPath: (sw) => {
+      const h = sw * 6 / 2;
+      return `M ${-h} ${-h} L ${h} ${-h} L ${h} ${h} L ${-h} ${h} Z`;
+    },
+    getLocalPoints: (sw) => {
+      const h = sw * 6 / 2;
+      return [
+        { x: -h, y: -h },
+        // TL
+        { x: h, y: -h },
+        // TR
+        { x: h, y: h },
+        // BR
+        { x: -h, y: h }
+        // BL
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    // keep your new orientation
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Diamond]: {
+    getSvgPath: (sw) => {
+      const h = sw * 6 / 2;
+      return `M 0 ${-h} L ${h} 0 L 0 ${h} L ${-h} 0 Z`;
+    },
+    getLocalPoints: (sw) => {
+      const h = sw * 6 / 2;
+      return [
+        { x: 0, y: -h },
+        { x: h, y: 0 },
+        { x: 0, y: h },
+        { x: -h, y: 0 }
+      ];
+    },
+    getRotation: (segmentAngle) => segmentAngle,
+    filled: true
+  },
+  [PdfAnnotationLineEnding.Butt]: createLineHandler(6, (angle) => angle + Math.PI / 2),
+  [PdfAnnotationLineEnding.Slash]: createLineHandler(18, (angle) => angle + Math.PI / 1.5)
 };
-const variantKeyFromAnnotation = (a) => makeVariantKey(a.type, a.intent);
+const EXTRA_PADDING = 1.2;
+function lineRectWithEndings(vertices, strokeWidth, endings) {
+  if (!vertices || vertices.length === 0) {
+    return { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 } };
+  }
+  const allPoints = [...vertices];
+  const toAngle = (a, b) => Math.atan2(b.y - a.y, b.x - a.x);
+  const processEnding = (endingType, tipPos, segmentAngle) => {
+    if (!endingType) return;
+    const handler = LINE_ENDING_HANDLERS[endingType];
+    if (!handler) return;
+    const localPts = handler.getLocalPoints(strokeWidth);
+    const rotationAngle = handler.getRotation(segmentAngle);
+    const transformedPts = localPts.map((p) => rotateAndTranslatePoint(p, rotationAngle, tipPos));
+    allPoints.push(...transformedPts);
+  };
+  if (vertices.length >= 2) {
+    const startAngle = toAngle(vertices[1], vertices[0]);
+    processEnding(endings == null ? void 0 : endings.start, vertices[0], startAngle);
+    const lastIdx = vertices.length - 1;
+    const endAngle = toAngle(vertices[lastIdx - 1], vertices[lastIdx]);
+    processEnding(endings == null ? void 0 : endings.end, vertices[lastIdx], endAngle);
+  }
+  if (allPoints.length <= 1) {
+    const point = vertices[0] || { x: 0, y: 0 };
+    const pad2 = strokeWidth;
+    return {
+      origin: { x: point.x - pad2, y: point.y - pad2 },
+      size: { width: pad2 * 2, height: pad2 * 2 }
+    };
+  }
+  const baseRect = rectFromPoints(allPoints);
+  const pad = strokeWidth / 2 + EXTRA_PADDING * strokeWidth;
+  return expandRect(baseRect, pad);
+}
+const vertsRect = (verts, sw) => expandRect(rectFromPoints(verts), sw / 2);
+function deriveRect(a) {
+  switch (a.type) {
+    /* mark‑ups already carry their real rect */
+    case PdfAnnotationSubtype.HIGHLIGHT:
+    case PdfAnnotationSubtype.UNDERLINE:
+    case PdfAnnotationSubtype.STRIKEOUT:
+    case PdfAnnotationSubtype.SQUIGGLY:
+    case PdfAnnotationSubtype.SQUARE:
+    case PdfAnnotationSubtype.CIRCLE:
+      return a.rect;
+    /* ink */
+    case PdfAnnotationSubtype.INK: {
+      const pts = a.inkList.flatMap((s) => s.points);
+      return vertsRect(pts, a.strokeWidth);
+    }
+    /* one‑segment */
+    case PdfAnnotationSubtype.LINE:
+      return lineRectWithEndings(
+        [a.linePoints.start, a.linePoints.end],
+        a.strokeWidth,
+        a.lineEndings
+      );
+    /* multi‑segment */
+    case PdfAnnotationSubtype.POLYLINE:
+      return lineRectWithEndings(a.vertices, a.strokeWidth, a.lineEndings);
+    case PdfAnnotationSubtype.POLYGON:
+      return vertsRect(a.vertices, a.strokeWidth);
+    default:
+      return a.rect;
+  }
+}
+function createEnding(ending, strokeWidth, rad, px, py) {
+  if (!ending) return null;
+  const handler = LINE_ENDING_HANDLERS[ending];
+  if (!handler) return null;
+  const toDeg = (r) => r * 180 / Math.PI;
+  const rotationAngle = handler.getRotation(rad);
+  return {
+    d: handler.getSvgPath(strokeWidth),
+    transform: `translate(${px} ${py}) rotate(${toDeg(rotationAngle)})`,
+    filled: handler.filled
+  };
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LINE_ENDING_HANDLERS,
+  createEnding,
+  deriveRect,
+  lineRectWithEndings
+}, Symbol.toStringTag, { value: "Module" }));
+function isInk(a) {
+  return a.object.type === PdfAnnotationSubtype.INK;
+}
+function isCircle(a) {
+  return a.object.type === PdfAnnotationSubtype.CIRCLE;
+}
+function isPolygon(a) {
+  return a.object.type === PdfAnnotationSubtype.POLYGON;
+}
+function isSquare(a) {
+  return a.object.type === PdfAnnotationSubtype.SQUARE;
+}
+function isLine(a) {
+  return a.object.type === PdfAnnotationSubtype.LINE;
+}
+function isPolyline(a) {
+  return a.object.type === PdfAnnotationSubtype.POLYLINE;
+}
+function isHighlight(a) {
+  return a.object.type === PdfAnnotationSubtype.HIGHLIGHT;
+}
+function isUnderline(a) {
+  return a.object.type === PdfAnnotationSubtype.UNDERLINE;
+}
+function isStrikeout(a) {
+  return a.object.type === PdfAnnotationSubtype.STRIKEOUT;
+}
+function isSquiggly(a) {
+  return a.object.type === PdfAnnotationSubtype.SQUIGGLY;
+}
+function isTextMarkup(a) {
+  return isHighlight(a) || isUnderline(a) || isStrikeout(a) || isSquiggly(a);
+}
+function isFreeText(a) {
+  return a.object.type === PdfAnnotationSubtype.FREETEXT;
+}
+function isHighlightDefaults(defaults) {
+  return defaults.subtype === PdfAnnotationSubtype.HIGHLIGHT;
+}
+function isUnderlineDefaults(defaults) {
+  return defaults.subtype === PdfAnnotationSubtype.UNDERLINE;
+}
+function isStrikeoutDefaults(defaults) {
+  return defaults.subtype === PdfAnnotationSubtype.STRIKEOUT;
+}
+function isSquigglyDefaults(defaults) {
+  return defaults.subtype === PdfAnnotationSubtype.SQUIGGLY;
+}
+function isTextMarkupDefaults(defaults) {
+  return isHighlightDefaults(defaults) || isUnderlineDefaults(defaults) || isStrikeoutDefaults(defaults) || isSquigglyDefaults(defaults);
+}
 const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
   constructor(id, registry, engine, config) {
     super(id, registry);
@@ -152,19 +414,17 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     (_c = this.selection) == null ? void 0 : _c.onEndSelection(() => {
       var _a2, _b2;
       if (!this.state.activeVariant) return;
-      if (!(this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.HIGHLIGHT) || this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.UNDERLINE) || this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.STRIKEOUT) || this.state.activeVariant === makeVariantKey(PdfAnnotationSubtype.SQUIGGLY))) {
-        return;
-      }
+      const defaults = this.state.toolDefaults[this.state.activeVariant];
+      if (!defaults || !isTextMarkupDefaults(defaults)) return;
       const formattedSelection = (_a2 = this.selection) == null ? void 0 : _a2.getFormattedSelection();
       if (!formattedSelection) return;
       for (const selection of formattedSelection) {
         const rect = selection.rect;
         const segmentRects = selection.segmentRects;
-        const type = this.state.activeVariant;
-        const subtype = this.state.toolDefaults[type].subtype;
-        const color = this.state.toolDefaults[type].color;
-        const opacity = this.state.toolDefaults[type].opacity;
-        const blendMode = this.state.toolDefaults[type].blendMode ?? PdfBlendMode.Normal;
+        const subtype = defaults.subtype;
+        const color = defaults.color;
+        const opacity = defaults.opacity;
+        const blendMode = defaults.blendMode ?? PdfBlendMode.Normal;
         this.createAnnotation(selection.pageIndex, {
           type: subtype,
           rect,
@@ -223,6 +483,9 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
           (_b = this.interactionManager) == null ? void 0 : _b.activate("default");
         }
       },
+      getSubtypeAndIntentByVariant: (variantKey) => {
+        return parseVariantKey(variantKey);
+      },
       getToolDefaults: (variantKey) => {
         const defaults = this.state.toolDefaults[variantKey];
         if (!defaults) {
@@ -231,19 +494,10 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
         return defaults;
       },
       getToolDefaultsBySubtypeAndIntent: (subtype, intent) => {
-        const variantKey = makeVariantKey(subtype, intent);
-        const defaults = this.state.toolDefaults[variantKey];
-        if (!defaults) {
-          throw new Error(`No defaults found for variant: ${variantKey}`);
-        }
-        return defaults;
+        return getToolDefaultsBySubtypeAndIntent(this.state, subtype, intent);
       },
       getToolDefaultsBySubtype: (subtype) => {
-        const defaults = this.state.toolDefaults[subtype];
-        if (!defaults) {
-          throw new Error(`No defaults found for subtype: ${subtype}`);
-        }
-        return defaults;
+        return getToolDefaultsBySubtypeAndIntent(this.state, subtype);
       },
       setToolDefaults: (variantKey, patch) => {
         this.dispatch(updateToolDefaults(variantKey, patch));
@@ -340,20 +594,26 @@ const _AnnotationPlugin = class _AnnotationPlugin extends BasePlugin {
     };
     this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
   }
+  buildPatch(original, patch) {
+    if ("rect" in patch) return patch;
+    const merged = { ...original, ...patch };
+    return { ...patch, rect: deriveRect(merged) };
+  }
   updateAnnotation(pageIndex, localId, patch) {
+    const originalObject = this.state.byUid[makeUid$1(pageIndex, localId)].object;
+    const finalPatch = this.buildPatch(originalObject, patch);
     if (!this.history) {
-      this.dispatch(patchAnnotation(pageIndex, localId, patch));
+      this.dispatch(patchAnnotation(pageIndex, localId, finalPatch));
       if (this.config.autoCommit !== false) {
         this.commit();
       }
       return;
     }
-    const originalObject = this.state.byUid[makeUid$1(pageIndex, localId)].object;
     const originalPatch = Object.fromEntries(
       Object.keys(patch).map((key) => [key, originalObject[key]])
     );
     const command = {
-      execute: () => this.dispatch(patchAnnotation(pageIndex, localId, patch)),
+      execute: () => this.dispatch(patchAnnotation(pageIndex, localId, finalPatch)),
       undo: () => this.dispatch(patchAnnotation(pageIndex, localId, originalPatch))
     };
     this.history.register(command, this.ANNOTATION_HISTORY_TOPIC);
@@ -454,7 +714,9 @@ const DEFAULT_COLORS = [
   "#25D2D1",
   "#597CE2",
   "#C544CE",
-  "#7D2E25"
+  "#7D2E25",
+  "#000000",
+  "#FFFFFF"
 ];
 const patchAnno = (state, uid, patch) => {
   const prev = state.byUid[uid];
@@ -526,12 +788,91 @@ const initialState = (cfg) => ({
     [makeVariantKey(PdfAnnotationSubtype.INK, "InkHighlight")]: {
       name: "Ink Highlight",
       subtype: PdfAnnotationSubtype.INK,
+      intent: "InkHighlight",
       interaction: { mode: "inkHighlight", exclusive: true, cursor: "crosshair" },
       color: "#E44234",
       opacity: 1,
       strokeWidth: 11,
       blendMode: PdfBlendMode.Multiply
     },
+    [makeVariantKey(PdfAnnotationSubtype.CIRCLE)]: {
+      name: "Circle",
+      subtype: PdfAnnotationSubtype.CIRCLE,
+      interaction: { mode: "circle", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.SQUARE)]: {
+      name: "Square",
+      subtype: PdfAnnotationSubtype.SQUARE,
+      interaction: { mode: "square", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.LINE)]: {
+      name: "Line",
+      subtype: PdfAnnotationSubtype.LINE,
+      interaction: { mode: "line", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.LINE, "LineArrow")]: {
+      name: "Line Arrow",
+      subtype: PdfAnnotationSubtype.LINE,
+      interaction: { mode: "lineArrow", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      intent: "LineArrow",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID,
+      lineEndings: {
+        start: PdfAnnotationLineEnding.None,
+        end: PdfAnnotationLineEnding.OpenArrow
+      }
+    },
+    [makeVariantKey(PdfAnnotationSubtype.POLYLINE)]: {
+      name: "Polyline",
+      subtype: PdfAnnotationSubtype.POLYLINE,
+      interaction: { mode: "polyline", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.POLYGON)]: {
+      name: "Polygon",
+      subtype: PdfAnnotationSubtype.POLYGON,
+      interaction: { mode: "polygon", exclusive: true, cursor: "crosshair" },
+      color: "transparent",
+      opacity: 1,
+      strokeWidth: 4,
+      strokeColor: "#E44234",
+      strokeStyle: PdfAnnotationBorderStyle.SOLID
+    },
+    [makeVariantKey(PdfAnnotationSubtype.FREETEXT)]: {
+      name: "Free Text",
+      subtype: PdfAnnotationSubtype.FREETEXT,
+      interaction: { mode: "freeText", exclusive: true, cursor: "crosshair" },
+      backgroundColor: "transparent",
+      opacity: 1,
+      fontSize: 14,
+      fontColor: "#E44234",
+      content: "Insert text here",
+      fontFamily: PdfStandardFont.Helvetica,
+      textAlign: PdfTextAlignment.Left,
+      verticalAlign: PdfVerticalAlignment.Top
+    },
     ...cfg.toolDefaults
   },
   colorPresets: cfg.colorPresets ?? DEFAULT_COLORS,
@@ -549,8 +890,8 @@ const reducer = (state, action) => {
         for (const uid of oldUidsOnPage) {
           delete newByUid[uid];
         }
-        const newUidsOnPage = list.map((a, index) => {
-          const localId = Date.now() + Math.random() + index;
+        const newUidsOnPage = list.map((a, index2) => {
+          const localId = Date.now() + Math.random() + index2;
           const uid = makeUid$1(pageIndex, localId);
           newByUid[uid] = { localId, pdfId: a.id, commitState: "synced", object: a };
           return uid;
@@ -680,11 +1021,30 @@ export {
   getSelectedAnnotationByPageIndex,
   getSelectedAnnotationVariant,
   getSelectedAnnotationWithPageIndex,
+  getToolDefaultsBySubtypeAndIntent,
   isAnnotationSelected,
+  isCircle,
+  isFreeText,
+  isHighlight,
+  isHighlightDefaults,
   isInAnnotationVariant,
+  isInk,
+  isLine,
+  isPolygon,
+  isPolyline,
+  isSquare,
+  isSquiggly,
+  isSquigglyDefaults,
+  isStrikeout,
+  isStrikeoutDefaults,
+  isTextMarkup,
+  isTextMarkupDefaults,
+  isUnderline,
+  isUnderlineDefaults,
   makeVariantKey,
   manifest,
   parseVariantKey,
+  index as patching,
   variantKeyFromAnnotation
 };
 //# sourceMappingURL=index.js.map