box-ui-elements 16.0.0-beta.8 → 16.0.0

package/src/elements/common/annotator-context/__tests__/withAnnotations.test.tsx

@@ -66,8 +66,20 @@ describe('elements/common/annotator-context/withAnnotations', () => {
         const contextProvider = getContextProvider(wrapper);
 
         expect(contextProvider.exists()).toBeTruthy();
-        expect(contextProvider.prop('value').emitActiveChangeEvent).toEqual(instance.emitActiveChangeEvent);
-        expect(contextProvider.prop('value').emitRemoveEvent).toEqual(instance.emitRemoveEvent);
+        expect(contextProvider.prop('value').emitActiveAnnotationChangeEvent).toEqual(
+            instance.emitActiveAnnotationChangeEvent,
+        );
+        expect(contextProvider.prop('value').emitAnnotationRemoveEvent).toEqual(instance.emitAnnotationRemoveEvent);
+        expect(contextProvider.prop('value').emitAnnotationReplyCreateEvent).toEqual(
+            instance.emitAnnotationReplyCreateEvent,
+        );
+        expect(contextProvider.prop('value').emitAnnotationReplyDeleteEvent).toEqual(
+            instance.emitAnnotationReplyDeleteEvent,
+        );
+        expect(contextProvider.prop('value').emitAnnotationReplyUpdateEvent).toEqual(
+            instance.emitAnnotationReplyUpdateEvent,
+        );
+        expect(contextProvider.prop('value').emitAnnotationUpdateEvent).toEqual(instance.emitAnnotationUpdateEvent);
         expect(contextProvider.prop('value').getAnnotationsMatchPath).toEqual(instance.getMatchPath);
         expect(contextProvider.prop('value').getAnnotationsPath).toEqual(instance.getAnnotationsPath);
         expect(contextProvider.prop('value').state).toEqual({
@@ -75,35 +87,132 @@ describe('elements/common/annotator-context/withAnnotations', () => {
             activeAnnotationFileVersionId: null,
             activeAnnotationId: null,
             annotation: null,
+            annotationReply: null,
             error: null,
             meta: null,
         });
     });
 
-    describe('emitActiveChangeEvent', () => {
+    describe('emitActiveAnnotationChangeEvent', () => {
         test('should call annotator emit on action', () => {
             const wrapper = getWrapper();
             const instance = wrapper.instance();
 
             // Set the annotator on the withAnnotations instance
             instance.handleAnnotator(mockAnnotator);
-            instance.emitActiveChangeEvent('123');
+            instance.emitActiveAnnotationChangeEvent('123');
 
             expect(mockAnnotator.emit).toBeCalled();
             expect(mockAnnotator.emit).toBeCalledWith('annotations_active_set', '123');
         });
     });
 
-    describe('emitRemoveEvent', () => {
-        test('should call annotator on delete with a delete event', () => {
-            const wrapper = getWrapper();
-            const instance = wrapper.instance();
+    describe('emitAnnotationRemoveEvent', () => {
+        test.each`
+            isStartEvent | expectedEvent
+            ${undefined} | ${'annotations_remove'}
+            ${false}     | ${'annotations_remove'}
+            ${true}      | ${'annotations_remove_start'}
+        `(
+            'given isStartEvent = $isStartEvent should call annotator emit with event = $expectedEvent',
+            ({ isStartEvent, expectedEvent }) => {
+                const wrapper = getWrapper();
+                const instance = wrapper.instance();
 
-            instance.handleAnnotator(mockAnnotator);
-            instance.emitRemoveEvent('123');
+                instance.handleAnnotator(mockAnnotator);
+                instance.emitAnnotationRemoveEvent('123', isStartEvent);
 
-            expect(mockAnnotator.emit).toBeCalledWith('annotations_remove', '123');
-        });
+                expect(mockAnnotator.emit).toBeCalledWith(expectedEvent, '123');
+            },
+        );
+    });
+
+    describe('emitAnnotationUpdateEvent', () => {
+        test.each`
+            isStartEvent | expectedEvent
+            ${undefined} | ${'sidebar.annotations_update'}
+            ${false}     | ${'sidebar.annotations_update'}
+            ${true}      | ${'sidebar.annotations_update_start'}
+        `(
+            'given isStartEvent = $isStartEvent should call annotator emit with event = $expectedEvent',
+            ({ isStartEvent, expectedEvent }) => {
+                const wrapper = getWrapper();
+                const instance = wrapper.instance();
+                const annotation = { id: '123', status: 'resolved' };
+
+                instance.handleAnnotator(mockAnnotator);
+                instance.emitAnnotationUpdateEvent(annotation, isStartEvent);
+
+                expect(mockAnnotator.emit).toBeCalledWith(expectedEvent, annotation);
+            },
+        );
+    });
+
+    describe('emitAnnotationReplyCreateEvent', () => {
+        test.each`
+            isStartEvent | expectedEvent
+            ${undefined} | ${'sidebar.annotations_reply_create'}
+            ${false}     | ${'sidebar.annotations_reply_create'}
+            ${true}      | ${'sidebar.annotations_reply_create_start'}
+        `(
+            'given isStartEvent = $isStartEvent should call annotator emit with event = $expectedEvent',
+            ({ isStartEvent, expectedEvent }) => {
+                const wrapper = getWrapper();
+                const instance = wrapper.instance();
+                const annotationId = '123';
+                const reply = { tagged_message: 'abc' };
+                const requestId = 'comment_123';
+
+                instance.handleAnnotator(mockAnnotator);
+                instance.emitAnnotationReplyCreateEvent(reply, requestId, annotationId, isStartEvent);
+
+                expect(mockAnnotator.emit).toBeCalledWith(expectedEvent, { annotationId, reply, requestId });
+            },
+        );
+    });
+
+    describe('emitAnnotationReplyDeleteEvent', () => {
+        test.each`
+            isStartEvent | expectedEvent
+            ${undefined} | ${'sidebar.annotations_reply_delete'}
+            ${false}     | ${'sidebar.annotations_reply_delete'}
+            ${true}      | ${'sidebar.annotations_reply_delete_start'}
+        `(
+            'given isStartEvent = $isStartEvent should call annotator emit with event = $expectedEvent',
+            ({ isStartEvent, expectedEvent }) => {
+                const wrapper = getWrapper();
+                const instance = wrapper.instance();
+                const annotationId = '123';
+                const replyId = '456';
+
+                instance.handleAnnotator(mockAnnotator);
+                instance.emitAnnotationReplyDeleteEvent(replyId, annotationId, isStartEvent);
+
+                expect(mockAnnotator.emit).toBeCalledWith(expectedEvent, { annotationId, id: replyId });
+            },
+        );
+    });
+
+    describe('emitAnnotationReplyUpdateEvent', () => {
+        test.each`
+            isStartEvent | expectedEvent
+            ${undefined} | ${'sidebar.annotations_reply_update'}
+            ${false}     | ${'sidebar.annotations_reply_update'}
+            ${true}      | ${'sidebar.annotations_reply_update_start'}
+        `(
+            'given isStartEvent = $isStartEvent should call annotator emit with event = $expectedEvent',
+            ({ isStartEvent, expectedEvent }) => {
+                const wrapper = getWrapper();
+                const instance = wrapper.instance();
+                const annotationId = '123';
+                const reply = { id: '456', tagged_message: 'resolved' };
+
+                instance.handleAnnotator(mockAnnotator);
+                instance.emitAnnotationReplyUpdateEvent(reply, annotationId, isStartEvent);
+
+                expect(mockAnnotator.emit).toBeCalledWith(expectedEvent, { annotationId, reply });
+            },
+        );
     });
 
     describe('handleAnnotationCreate()', () => {
@@ -137,6 +246,7 @@ describe('elements/common/annotator-context/withAnnotations', () => {
                     activeAnnotationFileVersionId: null,
                     activeAnnotationId: null,
                     annotation: expectedAnnotation,
+                    annotationReply: null,
                     error: expectedError,
                     meta: {
                         status,
@@ -162,6 +272,158 @@ describe('elements/common/annotator-context/withAnnotations', () => {
         });
     });
 
+    describe('handleAnnotationDelete()', () => {
+        test.each`
+            status            | expectedAction
+            ${Status.PENDING} | ${Action.DELETE_START}
+            ${Status.SUCCESS} | ${Action.DELETE_END}
+        `('should update the context provider value if $status status received', ({ status, expectedAction }) => {
+            const wrapper = getWrapper();
+            const annotation = { id: '123' };
+            const eventData = {
+                annotation,
+                meta: { status },
+            };
+
+            wrapper.instance().handleAnnotationDelete(eventData);
+            const contextProvider = getContextProvider(wrapper);
+
+            expect(contextProvider.exists()).toBeTruthy();
+            expect(contextProvider.prop('value').state).toEqual({
+                action: expectedAction,
+                activeAnnotationFileVersionId: null,
+                activeAnnotationId: null,
+                annotation,
+                annotationReply: null,
+                error: null,
+                meta: { status },
+            });
+        });
+    });
+
+    describe('handleAnnotationUpdate()', () => {
+        test.each`
+            status            | expectedAction
+            ${Status.PENDING} | ${Action.UPDATE_START}
+            ${Status.SUCCESS} | ${Action.UPDATE_END}
+        `('should update the context provider value if $status status received', ({ status, expectedAction }) => {
+            const wrapper = getWrapper();
+            const annotation = { id: '123', status: 'resolved' };
+            const eventData = {
+                annotation,
+                meta: { status },
+            };
+
+            wrapper.instance().handleAnnotationUpdate(eventData);
+            const contextProvider = getContextProvider(wrapper);
+
+            expect(contextProvider.exists()).toBeTruthy();
+            expect(contextProvider.prop('value').state).toEqual({
+                action: expectedAction,
+                activeAnnotationFileVersionId: null,
+                activeAnnotationId: null,
+                annotation,
+                annotationReply: null,
+                error: null,
+                meta: { status },
+            });
+        });
+    });
+
+    describe('handleAnnotationReplyCreate()', () => {
+        test.each`
+            status            | expectedAction
+            ${Status.PENDING} | ${Action.REPLY_CREATE_START}
+            ${Status.SUCCESS} | ${Action.REPLY_CREATE_END}
+        `('should update the context provider value if $status status received', ({ status, expectedAction }) => {
+            const wrapper = getWrapper();
+            const annotation = { id: '123', status: 'resolved' };
+            const annotationReply = { tagged_message: 'abc' };
+            const requestId = 'comment_123';
+            const eventData = {
+                annotation,
+                annotationReply,
+                meta: { status, requestId },
+            };
+
+            wrapper.instance().handleAnnotationReplyCreate(eventData);
+            const contextProvider = getContextProvider(wrapper);
+
+            expect(contextProvider.exists()).toBeTruthy();
+            expect(contextProvider.prop('value').state).toEqual({
+                action: expectedAction,
+                activeAnnotationFileVersionId: null,
+                activeAnnotationId: null,
+                annotation,
+                annotationReply,
+                error: null,
+                meta: { status, requestId },
+            });
+        });
+    });
+
+    describe('handleAnnotationReplyUpdate()', () => {
+        test.each`
+            status            | expectedAction
+            ${Status.PENDING} | ${Action.REPLY_UPDATE_START}
+            ${Status.SUCCESS} | ${Action.REPLY_UPDATE_END}
+        `('should update the context provider value if $status status received', ({ status, expectedAction }) => {
+            const wrapper = getWrapper();
+            const annotation = { id: '123', status: 'resolved' };
+            const annotationReply = { id: '123', tagged_message: 'abc' };
+            const eventData = {
+                annotation,
+                annotationReply,
+                meta: { status },
+            };
+
+            wrapper.instance().handleAnnotationReplyUpdate(eventData);
+            const contextProvider = getContextProvider(wrapper);
+
+            expect(contextProvider.exists()).toBeTruthy();
+            expect(contextProvider.prop('value').state).toEqual({
+                action: expectedAction,
+                activeAnnotationFileVersionId: null,
+                activeAnnotationId: null,
+                annotation,
+                annotationReply,
+                error: null,
+                meta: { status },
+            });
+        });
+    });
+
+    describe('handleAnnotationReplyDelete()', () => {
+        test.each`
+            status            | expectedAction
+            ${Status.PENDING} | ${Action.REPLY_DELETE_START}
+            ${Status.SUCCESS} | ${Action.REPLY_DELETE_END}
+        `('should update the context provider value if $status status received', ({ status, expectedAction }) => {
+            const wrapper = getWrapper();
+            const annotation = { id: '123' };
+            const annotationReply = { id: '123' };
+            const eventData = {
+                annotation,
+                annotationReply,
+                meta: { status },
+            };
+
+            wrapper.instance().handleAnnotationReplyDelete(eventData);
+            const contextProvider = getContextProvider(wrapper);
+
+            expect(contextProvider.exists()).toBeTruthy();
+            expect(contextProvider.prop('value').state).toEqual({
+                action: expectedAction,
+                activeAnnotationFileVersionId: null,
+                activeAnnotationId: null,
+                annotation,
+                annotationReply,
+                error: null,
+                meta: { status },
+            });
+        });
+    });
+
     describe('handleActiveChange()', () => {
         test.each`
             annotationId | fileVersionId | expectedAnnotationId | expectedFileVersionId
@@ -208,6 +470,7 @@ describe('elements/common/annotator-context/withAnnotations', () => {
                 activeAnnotationFileVersionId: null,
                 activeAnnotationId: null,
                 annotation: null,
+                annotationReply: null,
                 error: null,
                 meta: null,
             });

package/src/elements/common/annotator-context/__tests__/withAnnotatorContext.test.tsx

@@ -29,15 +29,23 @@ describe('elements/common/annotator-context/withAnnotatorContext', () => {
             annotation: { foo: 'bar' },
             action: Action.CREATE_START,
         };
-        const mockEmitAnnotatorChangeEvent = jest.fn();
-        const mockEmitRemoveEvent = jest.fn();
+        const mockEmitActiveAnnotationChangeEvent = jest.fn();
+        const mockEmitAnnotationRemoveEvent = jest.fn();
+        const mockEmitAnnotationReplyCreateEvent = jest.fn();
+        const mockEmitAnnotationReplyDeleteEvent = jest.fn();
+        const mockMmitAnnotationReplyUpdateEvent = jest.fn();
+        const mockEmitAnnotationUpdateEvent = jest.fn();
         const mockGetAnnotationsMatchPath = jest.fn();
         const mockGetAnnotationsPath = jest.fn();
 
         mockContext.mockReturnValue({
             state: annotatorState,
-            emitActiveChangeEvent: mockEmitAnnotatorChangeEvent,
-            emitRemoveEvent: mockEmitRemoveEvent,
+            emitActiveAnnotationChangeEvent: mockEmitActiveAnnotationChangeEvent,
+            emitAnnotationRemoveEvent: mockEmitAnnotationRemoveEvent,
+            emitAnnotationReplyCreateEvent: mockEmitAnnotationReplyCreateEvent,
+            emitAnnotationReplyDeleteEvent: mockEmitAnnotationReplyDeleteEvent,
+            emitAnnotationReplyUpdateEvent: mockMmitAnnotationReplyUpdateEvent,
+            emitAnnotationUpdateEvent: mockEmitAnnotationUpdateEvent,
             getAnnotationsMatchPath: mockGetAnnotationsMatchPath,
             getAnnotationsPath: mockGetAnnotationsPath,
         });
@@ -51,8 +59,12 @@ describe('elements/common/annotator-context/withAnnotatorContext', () => {
             annotation: { foo: 'bar' },
             action: Action.CREATE_START,
         });
-        expect(props.emitAnnotatorActiveChangeEvent).toEqual(mockEmitAnnotatorChangeEvent);
-        expect(props.emitRemoveEvent).toEqual(mockEmitRemoveEvent);
+        expect(props.emitActiveAnnotationChangeEvent).toEqual(mockEmitActiveAnnotationChangeEvent);
+        expect(props.emitAnnotationRemoveEvent).toEqual(mockEmitAnnotationRemoveEvent);
+        expect(props.emitAnnotationReplyCreateEvent).toEqual(mockEmitAnnotationReplyCreateEvent);
+        expect(props.emitAnnotationReplyDeleteEvent).toEqual(mockEmitAnnotationReplyDeleteEvent);
+        expect(props.emitAnnotationReplyUpdateEvent).toEqual(mockMmitAnnotationReplyUpdateEvent);
+        expect(props.emitAnnotationUpdateEvent).toEqual(mockEmitAnnotationUpdateEvent);
         expect(props.getAnnotationsMatchPath).toEqual(mockGetAnnotationsMatchPath);
         expect(props.getAnnotationsPath).toEqual(mockGetAnnotationsPath);
     });

package/src/elements/common/annotator-context/index.js.flow

@@ -5,6 +5,10 @@ declare export {
   WithAnnotationsComponent,
   ComponentWithAnnotations
 } from "./withAnnotations";
+    declare export {
+    default as useAnnotatorEvents,
+    UseAnnotatorEventsProps
+} from "./useAnnotatorEvents";
 declare export {
   default as withAnnotatorContext,
   WithAnnotatorContextProps

package/src/elements/common/annotator-context/index.ts

@@ -1,4 +1,5 @@
 export { default as AnnotatorContext } from './AnnotatorContext';
+export { default as useAnnotatorEvents } from './useAnnotatorEvents';
 export { default as withAnnotations } from './withAnnotations';
 export { default as withAnnotatorContext } from './withAnnotatorContext';
 export * from './types';

package/src/elements/common/annotator-context/types.js.flow

@@ -4,55 +4,97 @@
  * Flowgen v1.10.0
  */
 
+import { Location } from "history";
 import { match } from "react-router-dom";
-declare export var CREATE: "create";
+declare export var CREATE: any; // "create"
 declare export var Action: {|
-  +CREATE_START: "create_start", // "create_start"
-  +CREATE_END: "create_end" // "create_end"
+    +CREATE_START: "create_start", // "create_start"
+    +CREATE_END: "create_end", // "create_end"
+    +DELETE_START: "delete_start", // "delete_start"
+    +DELETE_END: "delete_end", // "delete_end"
+    +SET_ACTIVE: "set_active", // "set_active"
+    +UPDATE_START: "update_start", // "update_start"
+    +UPDATE_END: "update_end", // "update_end"
+    +REPLY_CREATE_START: "reply_create_start", // "reply_create_start"
+    +REPLY_CREATE_END: "reply_create_end", // "reply_create_end"
+    +REPLY_DELETE_START: "reply_delete_start", // "reply_delete_start"
+    +REPLY_DELETE_END: "reply_delete_end", // "reply_delete_end"
+    +REPLY_UPDATE_START: "reply_update_start", // "reply_update_start"
+    +REPLY_UPDATE_END: "reply_update_end" // "reply_update_end"
 |};
 export interface Annotator {
-  addListener: (
-    event: string | Symbol,
-    listener: (...args: any[]) => void
-  ) => void;
-  emit: (event: string | Symbol, ...args: any[]) => void;
-  removeAllListeners: () => void;
-  removeListener: (
-    event: string | Symbol,
-    listener: (...args: any[]) => void
-  ) => void;
+    addListener: (
+        event: string | Symbol,
+        listener: (...args: any[]) => void
+    ) => void;
+    emit: (event: string | Symbol, ...args: any[]) => void;
+    removeAllListeners: () => void;
+    removeListener: (
+        event: string | Symbol,
+        listener: (...args: any[]) => void
+    ) => void;
 }
 export interface AnnotatorState {
-  activeAnnotationId?: string | null;
-  annotation?: { [key: string]: any } | null;
-  action?: $Values<typeof Action> | null;
-  error?: Error | null;
-  meta?: Metadata | null;
+    activeAnnotationFileVersionId?: string | null;
+    activeAnnotationId?: string | null;
+    annotation?: {
+        id?: string,
+        ...
+    } | null;
+    annotationReply?: {
+        id?: string,
+        ...
+    } | null;
+    action?: $Values<typeof Action> | null;
+    error?: Error | null;
+    meta?: Metadata | null;
+    origin?: string;
 }
-export type GetMatchPath = (history: History) => match<MatchParams> | null;
+export type GetMatchPath = (location?: Location) => match<MatchParams> | null;
 export interface AnnotatorContext {
-  emitActiveChangeEvent: (id: string) => void;
-  emitRemoveEvent: (id: string) => void;
-  getAnnotationsMatchPath: GetMatchPath;
-  getAnnotationsPath: (fileVersionId?: string, annotationId?: string) => string;
-  state: AnnotatorState;
+    emitActiveAnnotationChangeEvent?: (id: string) => void;
+    emitAnnotationRemoveEvent?: (id: string, isStartEvent?: boolean) => void;
+    emitAnnotationReplyCreateEvent?: (
+        reply: Object,
+        requestId: string,
+        annotationId: string,
+        isStartEvent?: boolean
+    ) => void;
+    emitAnnotationReplyDeleteEvent?: (
+        id: string,
+        annotationId: string,
+        isStartEvent?: boolean
+    ) => void;
+    emitAnnotationReplyUpdateEvent?: (
+        reply: Object,
+        annotationId: string,
+        isStartEvent?: boolean
+    ) => void;
+    emitAnnotationUpdateEvent?: (
+        annotation: Object,
+        isStartEvent?: boolean
+    ) => void;
+    getAnnotationsMatchPath: GetMatchPath;
+    getAnnotationsPath: (fileVersionId?: string, annotationId?: string) => string;
+    state: AnnotatorState;
 }
 declare export var Status: {|
-  +ERROR: "error", // "error"
-  +PENDING: "pending", // "pending"
-  +SUCCESS: "success" // "success"
+    +ERROR: "error", // "error"
+    +PENDING: "pending", // "pending"
+    +SUCCESS: "success" // "success"
 |};
 export type MatchParams = {
-  annotationId?: string,
-  fileVersionId?: string,
-  ...
+    annotationId?: string,
+    fileVersionId?: string,
+    ...
 };
 export interface Metadata {
-  requestId: string;
-  status: $Values<typeof Status>;
+    requestId?: string;
+    status: $Values<typeof Status>;
 }
 export interface AnnotationActionEvent {
-  annotation?: { [key: string]: any };
-  error?: Error;
-  meta: Metadata;
+    annotation?: Object;
+    annotationReply?: Object;
+    error?: Error;
+    meta: Metadata;
 }

package/src/elements/common/annotator-context/types.ts

@@ -6,7 +6,17 @@ export const CREATE = 'create';
 export enum Action {
     CREATE_START = 'create_start',
     CREATE_END = 'create_end',
-    // Can extend to other actions: update_start, update_end, delete_start, delete_end
+    DELETE_START = 'delete_start',
+    DELETE_END = 'delete_end',
+    SET_ACTIVE = 'set_active',
+    UPDATE_START = 'update_start',
+    UPDATE_END = 'update_end',
+    REPLY_CREATE_START = 'reply_create_start',
+    REPLY_CREATE_END = 'reply_create_end',
+    REPLY_DELETE_START = 'reply_delete_start',
+    REPLY_DELETE_END = 'reply_delete_end',
+    REPLY_UPDATE_START = 'reply_update_start',
+    REPLY_UPDATE_END = 'reply_update_end',
 }
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -21,17 +31,28 @@ export interface Annotator {
 export interface AnnotatorState {
     activeAnnotationFileVersionId?: string | null;
     activeAnnotationId?: string | null;
-    annotation?: object | null;
+    annotation?: { id?: string } | null;
+    annotationReply?: { id?: string } | null;
     action?: Action | null;
     error?: Error | null;
     meta?: Metadata | null;
+    origin?: string;
 }
 
 export type GetMatchPath = (location?: Location) => match<MatchParams> | null;
 
 export interface AnnotatorContext {
-    emitActiveChangeEvent: (id: string) => void;
-    emitRemoveEvent: (id: string) => void;
+    emitActiveAnnotationChangeEvent?: (id: string) => void;
+    emitAnnotationRemoveEvent?: (id: string, isStartEvent?: boolean) => void;
+    emitAnnotationReplyCreateEvent?: (
+        reply: Object,
+        requestId: string,
+        annotationId: string,
+        isStartEvent?: boolean,
+    ) => void;
+    emitAnnotationReplyDeleteEvent?: (id: string, annotationId: string, isStartEvent?: boolean) => void;
+    emitAnnotationReplyUpdateEvent?: (reply: Object, annotationId: string, isStartEvent?: boolean) => void;
+    emitAnnotationUpdateEvent?: (annotation: Object, isStartEvent?: boolean) => void;
     getAnnotationsMatchPath: GetMatchPath;
     getAnnotationsPath: (fileVersionId?: string, annotationId?: string) => string;
     state: AnnotatorState;
@@ -49,12 +70,13 @@ export type MatchParams = {
 };
 
 export interface Metadata {
-    requestId: string;
+    requestId?: string;
     status: Status;
 }
 
 export interface AnnotationActionEvent {
-    annotation?: object;
+    annotation?: Object;
+    annotationReply?: Object;
     error?: Error;
     meta: Metadata;
 }

package/src/elements/common/annotator-context/useAnnotatorEvents.js.flow

@@ -0,0 +1,52 @@
+/**
+ * Flowtype definitions for useAnnotatorEvents.ts
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.10.0
+ */
+
+import * as React from "react";
+import { EventEmitter } from "events";
+import noop from "lodash/noop";
+import { AnnotationActionEvent, Status } from "./types";
+export interface UseAnnotatorEventsProps {
+    eventEmitter: EventEmitter;
+    onAnnotationDeleteEnd?: (annotationId: string) => void;
+    onAnnotationDeleteStart?: (annotationId: string) => void;
+    onAnnotationReplyAddEnd?: (eventData: {
+        annotationId: string,
+        reply: Object,
+        requestId: string,
+        ...
+    }) => void;
+    onAnnotationReplyAddStart?: (eventData: {
+        annotationId: string,
+        reply: Object,
+        requestId: string,
+        ...
+    }) => void;
+    onAnnotationReplyDeleteEnd?: (eventData: {
+        annotationId: string,
+        id: string,
+        ...
+    }) => void;
+    onAnnotationReplyDeleteStart?: (eventData: {
+        annotationId: string,
+        id: string,
+        ...
+    }) => void;
+    onAnnotationReplyUpdateEnd?: (eventData: {
+        annotationId: string,
+        reply: Object,
+        ...
+    }) => void;
+    onAnnotationReplyUpdateStart?: (eventData: {
+        annotationId: string,
+        reply: Object,
+        ...
+    }) => void;
+    onAnnotationUpdateEnd?: (annotation: Object) => void;
+    onAnnotationUpdateStart?: (annotation: Object) => void;
+    onSidebarAnnotationSelected?: (annotationId: string) => void;
+}
+declare function useAnnotatorEvents(x: UseAnnotatorEventsProps): void;
+declare export default typeof useAnnotatorEvents;