box-annotations 5.2.1-beta.7 → 5.3.0

package/src/store/eventing/delete.ts

@@ -0,0 +1,27 @@
+import eventManager from '../../common/EventManager';
+import { AppState } from '../types';
+import { AsyncAction, Status } from './types';
+import { Event } from '../../@types';
+
+const emitDeleteEvent = (action: AsyncAction<string, string>, status: Status): void => {
+    const { error, meta: { arg, requestId } = {}, payload } = action;
+    if (status === Status.SUCCESS && !payload) return;
+    const id = payload ?? arg;
+    eventManager.emit(Event.ANNOTATION_DELETE, {
+        annotation: id ? { id } : undefined,
+        error,
+        meta: { requestId, status },
+    });
+};
+
+const deleteHandler = (status: Status) => (
+    _prev: AppState,
+    _next: AppState,
+    action: AsyncAction,
+): void => emitDeleteEvent(action as AsyncAction<string, string>, status);
+
+const handleDeleteErrorEvents = deleteHandler(Status.ERROR);
+const handleDeletePendingEvents = deleteHandler(Status.PENDING);
+const handleDeleteSuccessEvents = deleteHandler(Status.SUCCESS);
+
+export { handleDeleteErrorEvents, handleDeletePendingEvents, handleDeleteSuccessEvents };

package/src/store/eventing/middleware.ts

@@ -2,28 +2,58 @@ import noop from 'lodash/noop';
 import { Action, Dispatch, Middleware, MiddlewareAPI } from '@reduxjs/toolkit';
 import {
     createAnnotationAction,
+    createReplyAction,
+    deleteAnnotationAction,
+    deleteReplyAction,
     fetchAnnotationsAction,
     setActiveAnnotationIdAction,
     setIsInitialized,
+    updateAnnotationAction,
+    updateReplyAction,
 } from '../annotations/actions';
 import { navigateBoundingBoxHighlightAction } from '../boundingBoxHighlights/actions';
 import { EventHandlerMap } from './types';
 import { handleActiveAnnotationEvents } from './active';
 import { handleAnnotationsInitialized } from './init';
+import { handleNavigateBoundingBoxHighlight } from './boundingBoxHighlightNav';
 import { handleCreateErrorEvents, handleCreatePendingEvents, handleCreateSuccessEvents } from './create';
+import { handleDeleteErrorEvents, handleDeletePendingEvents, handleDeleteSuccessEvents } from './delete';
 import { handleFetchErrorEvents } from './fetch';
-import { handleNavigateBoundingBoxHighlight } from './boundingBoxHighlightNav';
+import { handleToggleAnnotationModeAction } from './mode';
+import {
+    handleReplyCreateErrorEvents,
+    handleReplyCreatePendingEvents,
+    handleReplyCreateSuccessEvents,
+} from './replyCreate';
+import {
+    handleReplyDeleteErrorEvents,
+    handleReplyDeletePendingEvents,
+    handleReplyDeleteSuccessEvents,
+} from './replyDelete';
+import {
+    handleReplyUpdateErrorEvents,
+    handleReplyUpdatePendingEvents,
+    handleReplyUpdateSuccessEvents,
+} from './replyUpdate';
 import { handleResetCreatorAction, handleSetStagedAction } from './staged';
 import { handleSetStatusAction } from './status';
-import { handleToggleAnnotationModeAction } from './mode';
+import { handleUpdateErrorEvents, handleUpdatePendingEvents, handleUpdateSuccessEvents } from './update';
 import { resetCreatorAction, setStagedAction, setStatusAction } from '../creator';
 import { toggleAnnotationModeAction } from '../common/actions';
 
-// Array of event handlers based on redux action. To add handling for new events add an entry keyed by action
-const eventHandlers: EventHandlerMap = {
+export const eventHandlers: EventHandlerMap = {
     [createAnnotationAction.fulfilled.toString()]: handleCreateSuccessEvents,
     [createAnnotationAction.pending.toString()]: handleCreatePendingEvents,
     [createAnnotationAction.rejected.toString()]: handleCreateErrorEvents,
+    [createReplyAction.fulfilled.toString()]: handleReplyCreateSuccessEvents,
+    [createReplyAction.pending.toString()]: handleReplyCreatePendingEvents,
+    [createReplyAction.rejected.toString()]: handleReplyCreateErrorEvents,
+    [deleteAnnotationAction.fulfilled.toString()]: handleDeleteSuccessEvents,
+    [deleteAnnotationAction.pending.toString()]: handleDeletePendingEvents,
+    [deleteAnnotationAction.rejected.toString()]: handleDeleteErrorEvents,
+    [deleteReplyAction.fulfilled.toString()]: handleReplyDeleteSuccessEvents,
+    [deleteReplyAction.pending.toString()]: handleReplyDeletePendingEvents,
+    [deleteReplyAction.rejected.toString()]: handleReplyDeleteErrorEvents,
     [fetchAnnotationsAction.rejected.toString()]: handleFetchErrorEvents,
     [navigateBoundingBoxHighlightAction.toString()]: handleNavigateBoundingBoxHighlight,
     [resetCreatorAction.toString()]: handleResetCreatorAction,
@@ -32,6 +62,12 @@ const eventHandlers: EventHandlerMap = {
     [setStagedAction.toString()]: handleSetStagedAction,
     [setStatusAction.toString()]: handleSetStatusAction,
     [toggleAnnotationModeAction.toString()]: handleToggleAnnotationModeAction,
+    [updateAnnotationAction.fulfilled.toString()]: handleUpdateSuccessEvents,
+    [updateAnnotationAction.pending.toString()]: handleUpdatePendingEvents,
+    [updateAnnotationAction.rejected.toString()]: handleUpdateErrorEvents,
+    [updateReplyAction.fulfilled.toString()]: handleReplyUpdateSuccessEvents,
+    [updateReplyAction.pending.toString()]: handleReplyUpdatePendingEvents,
+    [updateReplyAction.rejected.toString()]: handleReplyUpdateErrorEvents,
 };
 
 function getEventingMiddleware(handlers: EventHandlerMap = eventHandlers): Middleware {

package/src/store/eventing/replyCreate.ts

@@ -0,0 +1,34 @@
+import eventManager from '../../common/EventManager';
+import { Reply , Event } from '../../@types';
+import { AppState } from '../types';
+import { AsyncAction, Status } from './types';
+
+type ReplyCreateArg = { annotationId: string; message: string };
+type ReplyCreatePayload = { annotationId: string; reply: Reply };
+
+const emitReplyCreateEvent = (
+    action: AsyncAction<ReplyCreateArg, ReplyCreatePayload>,
+    status: Status,
+): void => {
+    const { error, meta: { arg, requestId } = {}, payload } = action;
+    if (status === Status.SUCCESS && !payload?.reply) return;
+    const annotationId = payload?.annotationId ?? arg?.annotationId;
+    eventManager.emit(Event.ANNOTATION_REPLY_CREATE, {
+        annotation: annotationId ? { id: annotationId } : undefined,
+        annotationReply: payload?.reply,
+        error,
+        meta: { requestId, status },
+    });
+};
+
+const replyCreateHandler = (status: Status) => (
+    _prev: AppState,
+    _next: AppState,
+    action: AsyncAction,
+): void => emitReplyCreateEvent(action as AsyncAction<ReplyCreateArg, ReplyCreatePayload>, status);
+
+const handleReplyCreateErrorEvents = replyCreateHandler(Status.ERROR);
+const handleReplyCreatePendingEvents = replyCreateHandler(Status.PENDING);
+const handleReplyCreateSuccessEvents = replyCreateHandler(Status.SUCCESS);
+
+export { handleReplyCreateErrorEvents, handleReplyCreatePendingEvents, handleReplyCreateSuccessEvents };

package/src/store/eventing/replyDelete.ts

@@ -0,0 +1,35 @@
+import eventManager from '../../common/EventManager';
+import { AppState } from '../types';
+import { AsyncAction, Status } from './types';
+import { Event } from '../../@types';
+
+type ReplyDeleteArg = { annotationId: string; replyId: string };
+type ReplyDeletePayload = { annotationId: string; replyId: string };
+
+const emitReplyDeleteEvent = (
+    action: AsyncAction<ReplyDeleteArg, ReplyDeletePayload>,
+    status: Status,
+): void => {
+    const { error, meta: { arg, requestId } = {}, payload } = action;
+    if (status === Status.SUCCESS && !payload) return;
+    const annotationId = payload?.annotationId ?? arg?.annotationId;
+    const replyId = payload?.replyId ?? arg?.replyId;
+    eventManager.emit(Event.ANNOTATION_REPLY_DELETE, {
+        annotation: annotationId ? { id: annotationId } : undefined,
+        annotationReply: replyId ? { id: replyId } : undefined,
+        error,
+        meta: { requestId, status },
+    });
+};
+
+const replyDeleteHandler = (status: Status) => (
+    _prev: AppState,
+    _next: AppState,
+    action: AsyncAction,
+): void => emitReplyDeleteEvent(action as AsyncAction<ReplyDeleteArg, ReplyDeletePayload>, status);
+
+const handleReplyDeleteErrorEvents = replyDeleteHandler(Status.ERROR);
+const handleReplyDeletePendingEvents = replyDeleteHandler(Status.PENDING);
+const handleReplyDeleteSuccessEvents = replyDeleteHandler(Status.SUCCESS);
+
+export { handleReplyDeleteErrorEvents, handleReplyDeletePendingEvents, handleReplyDeleteSuccessEvents };

package/src/store/eventing/replyUpdate.ts

@@ -0,0 +1,39 @@
+import eventManager from '../../common/EventManager';
+import { Reply , Event } from '../../@types';
+import { AppState } from '../types';
+import { AsyncAction, Status } from './types';
+
+type ReplyUpdateArg = {
+    annotationId: string;
+    replyId: string;
+    payload: { message?: string; status?: string };
+};
+type ReplyUpdatePayload = { annotationId: string; reply: Reply };
+
+const emitReplyUpdateEvent = (
+    action: AsyncAction<ReplyUpdateArg, ReplyUpdatePayload>,
+    status: Status,
+): void => {
+    const { error, meta: { arg, requestId } = {}, payload } = action;
+    if (status === Status.SUCCESS && !payload?.reply) return;
+    const annotationId = payload?.annotationId ?? arg?.annotationId;
+    const annotationReply = payload?.reply ?? (arg ? { id: arg.replyId } : undefined);
+    eventManager.emit(Event.ANNOTATION_REPLY_UPDATE, {
+        annotation: annotationId ? { id: annotationId } : undefined,
+        annotationReply,
+        error,
+        meta: { requestId, status },
+    });
+};
+
+const replyUpdateHandler = (status: Status) => (
+    _prev: AppState,
+    _next: AppState,
+    action: AsyncAction,
+): void => emitReplyUpdateEvent(action as AsyncAction<ReplyUpdateArg, ReplyUpdatePayload>, status);
+
+const handleReplyUpdateErrorEvents = replyUpdateHandler(Status.ERROR);
+const handleReplyUpdatePendingEvents = replyUpdateHandler(Status.PENDING);
+const handleReplyUpdateSuccessEvents = replyUpdateHandler(Status.SUCCESS);
+
+export { handleReplyUpdateErrorEvents, handleReplyUpdatePendingEvents, handleReplyUpdateSuccessEvents };

package/src/store/eventing/types.ts

@@ -1,6 +1,6 @@
 import { Action, SerializedError } from '@reduxjs/toolkit';
 import { AppState } from '../types';
-import { Annotation, NewAnnotation } from '../../@types';
+import { Annotation } from '../../@types';
 
 export enum Status {
     ERROR = 'error',
@@ -22,10 +22,10 @@ export interface ThunkMeta<M> {
     requestId: string;
 }
 
-export interface AsyncAction extends Action {
+export interface AsyncAction<TArg = unknown, TPayload = unknown> extends Action {
     error?: SerializedError;
-    meta?: ThunkMeta<NewAnnotation>;
-    payload?: Annotation;
+    meta?: ThunkMeta<TArg>;
+    payload?: TPayload;
 }
 
 export type EventHandler = (prevState: AppState, nextState: AppState, action: Action | AsyncAction) => void;

package/src/store/eventing/update.ts

@@ -0,0 +1,29 @@
+import eventManager from '../../common/EventManager';
+import { Annotation , Event } from '../../@types';
+import { AppState } from '../types';
+import { AsyncAction, Status } from './types';
+
+type UpdateArg = { annotationId: string; payload: { message?: string; status?: string } };
+
+const emitUpdateEvent = (action: AsyncAction<UpdateArg, Annotation>, status: Status): void => {
+    const { error, meta: { arg, requestId } = {}, payload } = action;
+    if (status === Status.SUCCESS && !payload) return;
+    const annotation = payload ?? (arg ? { id: arg.annotationId } : undefined);
+    eventManager.emit(Event.ANNOTATION_UPDATE, {
+        annotation,
+        error,
+        meta: { requestId, status },
+    });
+};
+
+const updateHandler = (status: Status) => (
+    _prev: AppState,
+    _next: AppState,
+    action: AsyncAction,
+): void => emitUpdateEvent(action as AsyncAction<UpdateArg, Annotation>, status);
+
+const handleUpdateErrorEvents = updateHandler(Status.ERROR);
+const handleUpdatePendingEvents = updateHandler(Status.PENDING);
+const handleUpdateSuccessEvents = updateHandler(Status.SUCCESS);
+
+export { handleUpdateErrorEvents, handleUpdatePendingEvents, handleUpdateSuccessEvents };

package/src/store/highlight/actions.ts

@@ -1,13 +1,16 @@
 import { createAction } from '@reduxjs/toolkit';
-import { combineRects } from '../../highlight/highlightUtil';
+import { combineRects, getBoundingRect } from '../../highlight/highlightUtil';
+import { getElementLocalPosition } from '../../utils/rotate';
 import { SelectionItem } from './types';
 import { Shape } from '../../@types';
 
 export type SelectionArg = {
+    containerEl?: HTMLElement | null;
     containerRect: DOMRect;
     hasError?: boolean;
     location: number;
     range: Range;
+    rotation?: number;
 };
 
 type Payload = {
@@ -83,7 +86,7 @@ export const setSelectionAction = createAction(
             };
         }
 
-        const { containerRect, hasError, location, range } = arg;
+        const { containerEl, containerRect, hasError, location, range, rotation } = arg;
 
         let rects = Array.from(range.getClientRects());
         // getClientRects on IE/Edge might return 0 rects
@@ -91,12 +94,38 @@ export const setSelectionAction = createAction(
             rects = getClientRects(range);
         }
 
+        const screenShapes = rects.map(getShape);
+
+        if (rotation && containerEl) {
+            // Convert screen rects to element-local coordinates
+            const localRects = screenShapes.map(shape => {
+                const [lx1, ly1] = getElementLocalPosition(shape.x, shape.y, containerEl, rotation);
+                const [lx2, ly2] = getElementLocalPosition(shape.x + shape.width, shape.y + shape.height, containerEl, rotation);
+                return {
+                    x: Math.min(lx1, lx2),
+                    y: Math.min(ly1, ly2),
+                    width: Math.abs(lx2 - lx1),
+                    height: Math.abs(ly2 - ly1),
+                };
+            });
+
+            return {
+                payload: {
+                    containerRect: { x: 0, y: 0, width: containerEl.offsetWidth, height: containerEl.offsetHeight },
+                    hasError,
+                    location,
+                    popupRect: getBoundingRect(screenShapes),
+                    rects: combineRects(localRects),
+                },
+            };
+        }
+
         return {
             payload: {
                 containerRect: getShape(containerRect),
                 hasError,
                 location,
-                rects: combineRects(rects.map(getShape)),
+                rects: combineRects(screenShapes),
             },
         };
     },

package/src/store/highlight/types.ts

@@ -10,5 +10,6 @@ export type SelectionItem = {
     containerRect: Shape;
     hasError?: boolean;
     location: number;
+    popupRect?: Shape;
     rects: Array<Shape>;
 };

package/src/store/options/selectors.ts

@@ -1,6 +1,6 @@
 import getProp from 'lodash/get';
 import { AppState } from '../types';
-import { Permissions } from '../../@types';
+import { Permissions, Token } from '../../@types';
 import { Features } from '../../BoxAnnotations';
 import { ViewMode } from './types';
 
@@ -15,6 +15,6 @@ export const getIsCurrentFileVersion = (state: State): boolean => state.options.
 export const getPermissions = (state: State): Permissions => state.options.permissions;
 export const getRotation = (state: State): number => state.options.rotation;
 export const getScale = (state: State): number => state.options.scale;
-export const getToken = (state: State): string => state.options.token;
+export const getToken = (state: State): Token => state.options.token;
 export const isFeatureEnabled = (state: State, featurename: string): boolean =>
     getProp(getFeatures(state), featurename, false);

package/src/store/options/types.ts

@@ -1,5 +1,5 @@
 import { Features } from '../../BoxAnnotations';
-import { Permissions } from '../../@types';
+import { Permissions, Token } from '../../@types';
 
 /** View mode: annotations and bounding boxes are mutually exclusive. */
 export type ViewMode = 'annotations' | 'boundingBoxes';
@@ -13,6 +13,6 @@ export type OptionsState = {
     permissions: Permissions;
     rotation: number;
     scale: number;
-    token: string;
+    token: Token;
     viewMode: ViewMode;
 };

package/src/utils/rotate.ts

@@ -129,3 +129,46 @@ export function getRotatedPosition({ x, y }: Position, rotation: number): Positi
     const { x: rotatedX, y: rotatedY } = getRotatedShape({ height: 0, width: 0, x, y }, rotation);
     return { x: rotatedX, y: rotatedY };
 }
+
+/**
+ * Converts a mouse position (in browser window coordinates) to a position relative to
+ * a CSS-rotated element's own top-left corner.
+ *
+ * When an element has a CSS rotation, its internal axes are rotated with it.
+ * This function maps window coordinates to element-local coordinates.
+ *
+ * If element is null, returns the raw coordinates as a passthrough.
+ *
+ * Assumes transform-origin: center (the CSS default), which matches how
+ * box-content-preview applies rotation to annotation layers.
+ */
+export function getElementLocalPosition(
+    clientX: number,
+    clientY: number,
+    element: HTMLElement | null,
+    rotation: number,
+): [number, number] {
+    if (!element) {
+        return [clientX, clientY];
+    }
+
+    const rect = element.getBoundingClientRect();
+
+    if (!rotation) {
+        return [clientX - rect.left, clientY - rect.top];
+    }
+
+    // 1. Find the element's center (rotation doesn't move the center)
+    const centerX = rect.left + rect.width / 2;
+    const centerY = rect.top + rect.height / 2;
+
+    // 2. Get the mouse position relative to the center (in browser window coordinates)
+    const relX = clientX - centerX;
+    const relY = clientY - centerY;
+
+    // 3. Apply inverse rotation to obtain the mouse position from center in element-local coordinates
+    const local = rotatePoint({ x: relX, y: relY }, -rotation);
+
+    // 4. Convert coordinates from center-relative to top-left-relative
+    return [local.x + element.offsetWidth / 2, local.y + element.offsetHeight / 2];
+}