box-annotations 5.2.1-beta.2 → 5.2.1-beta.20

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/index.ts

@@ -5,6 +5,7 @@ export * from './annotations';
 export * from './common';
 export * from './creator';
 export * from './highlight';
+export * from './boundingBoxHighlights';
 export * from './options';
 export * from './types';
 export * from './users';

package/src/store/options/actions.ts

@@ -1,8 +1,10 @@
 import { createAction } from '@reduxjs/toolkit';
 import { Permissions } from '../../@types';
+import { ViewMode } from './types';
 
 export const setFileIdAction = createAction<string | null>('SET_FIlE_ID');
 export const setFileVersionIdAction = createAction<string | null>('SET_FILE_VERSION_ID');
 export const setPermissionsAction = createAction<Permissions>('SET_PERMISSIONS');
 export const setRotationAction = createAction<number>('SET_ROTATION');
 export const setScaleAction = createAction<number>('SET_SCALE');
+export const setViewModeAction = createAction<ViewMode>('SET_VIEW_MODE');

package/src/store/options/reducer.ts

@@ -1,14 +1,16 @@
 import { createReducer } from '@reduxjs/toolkit';
-import { OptionsState } from './types';
+import { OptionsState, ViewMode } from './types';
 import {
     setFileIdAction,
     setFileVersionIdAction,
     setPermissionsAction,
     setRotationAction,
     setScaleAction,
+    setViewModeAction,
 } from './actions';
 
-export const initialState = {
+export const initialState: OptionsState = {
+    apiHost: '',
     features: {},
     fileId: null,
     fileVersionId: null,
@@ -16,6 +18,8 @@ export const initialState = {
     permissions: {},
     rotation: 0,
     scale: 1,
+    token: '',
+    viewMode: 'annotations' as ViewMode,
 };
 
 export default createReducer<OptionsState>(initialState, builder =>
@@ -34,5 +38,8 @@ export default createReducer<OptionsState>(initialState, builder =>
         })
         .addCase(setScaleAction, (state, { payload }) => {
             state.scale = payload;
+        })
+        .addCase(setViewModeAction, (state, { payload }) => {
+            state.viewMode = payload;
         }),
 );

package/src/store/options/selectors.ts

@@ -1,16 +1,20 @@
 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';
 
 type State = Pick<AppState, 'options'>;
 
+export const getApiHost = (state: State): string => state.options.apiHost;
 export const getFeatures = (state: State): Features => state.options.features;
+export const getViewMode = (state: State): ViewMode => state.options.viewMode;
 export const getFileId = (state: State): string | null => state.options.fileId;
 export const getFileVersionId = (state: State): string | null => state.options.fileVersionId;
 export const getIsCurrentFileVersion = (state: State): boolean => state.options.isCurrentFileVersion;
 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): Token => state.options.token;
 export const isFeatureEnabled = (state: State, featurename: string): boolean =>
     getProp(getFeatures(state), featurename, false);

package/src/store/options/types.ts

@@ -1,7 +1,11 @@
 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';
 
 export type OptionsState = {
+    apiHost: string;
     features: Features;
     fileId: string | null;
     fileVersionId: string | null;
@@ -9,4 +13,6 @@ export type OptionsState = {
     permissions: Permissions;
     rotation: number;
     scale: number;
+    token: Token;
+    viewMode: ViewMode;
 };

package/src/store/types.ts

@@ -6,6 +6,7 @@ import { CommonState } from './common';
 import { CreatorState } from './creator';
 import { DrawingState } from './drawing';
 import { HighlightState } from './highlight';
+import { BoundingBoxHighlightsState } from './boundingBoxHighlights';
 import { OptionsState } from './options';
 import { UsersState } from './users';
 
@@ -15,6 +16,7 @@ export type AppState = {
     creator: CreatorState;
     drawing: DrawingState;
     highlight: HighlightState;
+    boundingBoxHighlights: BoundingBoxHighlightsState;
     options: OptionsState;
     users: UsersState;
 };

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];
+}

package/src/utils/scroll.ts

@@ -2,13 +2,14 @@ import { Position } from '../@types';
 
 export type ScrollOptions = {
     offsets?: Position;
+    smooth?: boolean;
     threshold?: number;
 };
 
 const DEFAULT_OFFSETS = { x: 0, y: 0 };
 
 export function scrollToLocation(parentEl: HTMLElement, referenceEl: HTMLElement, options: ScrollOptions = {}): void {
-    const { offsets = DEFAULT_OFFSETS } = options;
+    const { offsets = DEFAULT_OFFSETS, smooth = false } = options;
     const { x: offsetXPercentage, y: offsetYPercentage } = offsets;
     // Get the bounding client rects so that the offsetLeft of the reference element can be calculated --
     // even if it has been transformed via rotation
@@ -40,6 +41,10 @@ export function scrollToLocation(parentEl: HTMLElement, referenceEl: HTMLElement
     const scrollLeft = Math.max(0, Math.min(parentEl.scrollLeft + offsetScrollLeft, parentEl.scrollWidth));
     const scrollTop = Math.max(0, Math.min(parentEl.scrollTop + offsetScrollTop, parentEl.scrollHeight));
 
-    parentEl.scrollLeft = scrollLeft;
-    parentEl.scrollTop = scrollTop;
+    if (smooth) {
+        parentEl.scrollTo({ left: scrollLeft, top: scrollTop, behavior: 'smooth' });
+    } else {
+        parentEl.scrollLeft = scrollLeft;
+        parentEl.scrollTop = scrollTop;
+    }
 }

package/src/components/Popups/PopupReplyV2.tsx

@@ -1,10 +0,0 @@
-import React from 'react';
-
-/**
- * Placeholder for the threaded annotation reply popup (V2).
- * Replaces PopupReply when the isThreadedAnnotation feature flag is enabled.
- * Currently renders an empty container — props will be wired up when V2 is implemented.
- */
-export default function PopupReplyV2(): JSX.Element {
-    return <div data-testid="popup-reply-v2" />;
-}