@recogito/text-annotator 3.0.0-rc.43 → 3.0.0-rc.45

package/dist/src/TextAnnotator.d.ts

@@ -3,10 +3,10 @@ import { HighlightStyleExpression } from './highlight';
 import { TextAnnotatorState } from './state';
 import { TextAnnotation } from './model';
 import { TextAnnotatorOptions } from './TextAnnotatorOptions';
-export interface TextAnnotator<E extends unknown = TextAnnotation> extends Annotator<TextAnnotation, E> {
+export interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Annotator<TextAnnotation, E> {
     element: HTMLElement;
     setStyle(style: HighlightStyleExpression | undefined): void;
-    scrollIntoView(annotation: TextAnnotation): boolean;
-    state: TextAnnotatorState;
+    scrollIntoView(annotation: I): boolean;
+    state: TextAnnotatorState<I>;
 }
-export declare const createTextAnnotator: <E extends unknown = TextAnnotation>(container: HTMLElement, options?: TextAnnotatorOptions<E>) => TextAnnotator<E>;
+export declare const createTextAnnotator: <E extends unknown = TextAnnotation>(container: HTMLElement, options?: TextAnnotatorOptions<TextAnnotation, E>) => TextAnnotator<TextAnnotation, E>;

package/dist/src/TextAnnotatorOptions.d.ts

@@ -2,8 +2,8 @@ import { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/co
 import { PresencePainterOptions } from './presence';
 import { TextAnnotation } from './model';
 import { HighlightStyleExpression } from './highlight';
-export interface TextAnnotatorOptions<T extends unknown = TextAnnotation> {
-    adapter?: FormatAdapter<TextAnnotation, T> | null;
+export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
+    adapter?: FormatAdapter<I, E> | null;
     annotatingEnabled?: boolean;
     renderer?: RendererType;
     offsetReferenceSelector?: string;
@@ -13,4 +13,4 @@ export interface TextAnnotatorOptions<T extends unknown = TextAnnotation> {
     user?: User;
 }
 export type RendererType = 'SPANS' | 'CANVAS' | 'CSS_HIGHLIGHTS';
-export declare const fillDefaults: <T extends unknown = TextAnnotation>(opts: TextAnnotatorOptions<T>, defaults: TextAnnotatorOptions<T>) => TextAnnotatorOptions<T>;
+export declare const fillDefaults: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(opts: TextAnnotatorOptions<I, E>, defaults: TextAnnotatorOptions<I, E>) => TextAnnotatorOptions<I, E>;

package/dist/src/highlight/baseRenderer.d.ts

@@ -17,4 +17,4 @@ export interface Renderer {
     setPainter(painter?: HighlightPainter): void;
     setVisible(visible: boolean): void;
 }
-export declare const createBaseRenderer: (container: HTMLElement, state: TextAnnotatorState, viewport: ViewportState, renderer: RendererImplementation) => Renderer;
+export declare const createBaseRenderer: <T extends TextAnnotatorState = TextAnnotatorState<import('..').TextAnnotation>>(container: HTMLElement, state: T, viewport: ViewportState, renderer: RendererImplementation) => Renderer;

package/dist/src/highlight/span/spansRenderer.d.ts

@@ -1,3 +1,3 @@
 import { ViewportState } from '@annotorious/core';
 import { TextAnnotatorState } from '../../state';
-export declare const createSpansRenderer: (container: HTMLElement, state: TextAnnotatorState, viewport: ViewportState) => import('../baseRenderer').Renderer;
+export declare const createSpansRenderer: <T extends TextAnnotatorState = TextAnnotatorState<import('../..').TextAnnotation>>(container: HTMLElement, state: T, viewport: ViewportState) => import('../baseRenderer').Renderer;

package/dist/src/index.d.ts

@@ -1,9 +1,11 @@
+export * from './api';
 export * from './highlight';
 export * from './model';
 export * from './state';
 export * from './utils';
-export * from './presence/PresencePainterOptions';
+export * from './presence';
+export * from './SelectionHandler';
 export * from './TextAnnotator';
 export * from './TextAnnotatorOptions';
-export type { Annotation, AnnotationBody, AnnotationTarget, Annotator, AnnotatorState, Color, Filter, FormatAdapter, HoverState, Selection, SelectionState, Store, StoreChangeEvent, StoreObserver, ParseResult, User, UserSelectActionExpression, W3CAnnotation, W3CAnnotationBody, W3CAnnotationTarget } from '@annotorious/core';
+export type { Annotation, AnnotationBody, AnnotationTarget, Annotator, AnnotatorState, Color, Filter, FormatAdapter, HoverState, Selection, SelectionState, Store, StoreChangeEvent, StoreObserver, ParseResult, User, UserSelectActionExpression, ViewportState, W3CAnnotation, W3CAnnotationBody, W3CAnnotationTarget } from '@annotorious/core';
 export { createBody, Origin, UserSelectAction } from '@annotorious/core';

package/dist/src/presence/PresencePainter.d.ts

@@ -1,4 +1,4 @@
 import { PresenceProvider } from '@annotorious/core';
 import { HighlightPainter } from '../highlight';
 import { PresencePainterOptions } from '../presence';
-export declare const createPresencePainter: (container: HTMLElement, provider: PresenceProvider, opts?: PresencePainterOptions) => HighlightPainter;
+export declare const createPresencePainter: (provider: PresenceProvider, opts?: PresencePainterOptions) => HighlightPainter;

package/dist/src/state/TextAnnotationStore.d.ts

@@ -1,16 +1,17 @@
 import { Filter, Origin, Store } from '@annotorious/core';
 import { TextAnnotation } from '../model';
-export interface TextAnnotationStore extends Omit<Store<TextAnnotation>, 'addAnnotation' | 'bulkAddAnnotation'> {
-    addAnnotation(annotation: TextAnnotation, origin?: Origin): boolean;
-    bulkAddAnnotation(annotations: TextAnnotation[], replace: boolean, origin?: Origin): TextAnnotation[];
-    bulkUpsertAnnotations(annotations: TextAnnotation[], origin?: Origin): TextAnnotation[];
+export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotation'> {
+    addAnnotation(annotation: T, origin?: Origin): boolean;
+    bulkAddAnnotation(annotations: T[], replace: boolean, origin?: Origin): T[];
+    bulkUpsertAnnotations(annotations: T[], origin?: Origin): T[];
     getAnnotationBounds(id: string, hintX?: number, hintY?: number, buffer?: number): DOMRect;
-    getAt(x: number, y: number, filter?: Filter): TextAnnotation | undefined;
-    getIntersecting(minX: number, minY: number, maxX: number, maxY: number): AnnotationRects[];
+    getAnnotationRects(id: string): DOMRect[];
+    getAt(x: number, y: number, filter?: Filter): T | undefined;
+    getIntersecting(minX: number, minY: number, maxX: number, maxY: number): AnnotationRects<T>[];
     recalculatePositions(): void;
 }
-export interface AnnotationRects {
-    annotation: TextAnnotation;
+export interface AnnotationRects<T extends TextAnnotation = TextAnnotation> {
+    annotation: T;
     rects: Rect[];
 }
 export interface Rect {

package/dist/src/state/TextAnnotatorState.d.ts

@@ -1,10 +1,10 @@
 import { ViewportState, UserSelectActionExpression, AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
 import { TextAnnotation } from '../model';
 import { TextAnnotationStore } from './TextAnnotationStore';
-export interface TextAnnotatorState extends AnnotatorState<TextAnnotation> {
-    store: TextAnnotationStore;
-    selection: SelectionState<TextAnnotation>;
-    hover: HoverState<TextAnnotation>;
+export interface TextAnnotatorState<T extends TextAnnotation = TextAnnotation> extends AnnotatorState<T> {
+    store: TextAnnotationStore<T>;
+    selection: SelectionState<T>;
+    hover: HoverState<T>;
     viewport: ViewportState;
 }
-export declare const createTextAnnotatorState: (container: HTMLElement, defaultUserSelectAction?: UserSelectActionExpression<TextAnnotation>) => TextAnnotatorState;
+export declare const createTextAnnotatorState: <T extends TextAnnotation>(container: HTMLElement, defaultUserSelectAction?: UserSelectActionExpression<TextAnnotation>) => TextAnnotatorState<T>;

package/dist/src/state/spatialTree.d.ts

@@ -11,13 +11,13 @@ interface IndexedHighlightRect {
         rects: DOMRect[];
     };
 }
-export declare const createSpatialTree: (store: Store<TextAnnotation>, container: HTMLElement) => {
+export declare const createSpatialTree: <T extends TextAnnotation>(store: Store<T>, container: HTMLElement) => {
     all: () => IndexedHighlightRect[][];
     clear: () => void;
     getAt: (x: number, y: number, all?: boolean) => string[];
     getAnnotationBounds: (id: string) => DOMRect;
     getAnnotationRects: (id: string) => DOMRect[];
-    getIntersecting: (minX: number, minY: number, maxX: number, maxY: number) => AnnotationRects[];
+    getIntersecting: (minX: number, minY: number, maxX: number, maxY: number) => AnnotationRects<T>[];
     insert: (target: TextAnnotationTarget) => void;
     recalculate: () => void;
     remove: (target: TextAnnotationTarget) => void;

package/dist/src/utils/index.d.ts

@@ -1,7 +1,6 @@
 export * from './cancelSingleClickEvents';
 export * from './debounce';
 export * from './getAnnotatableFragment';
-export * from './getClientRectsPonyfill';
 export * from './getQuoteContext';
 export * from './isWhitespaceOrEmpty';
 export * from './isRevived';

package/dist/src/utils/reviveAnnotation.d.ts

@@ -1,2 +1,2 @@
 import { TextAnnotation } from '../model';
-export declare const reviveAnnotation: (annotation: TextAnnotation, container: HTMLElement) => TextAnnotation;
+export declare const reviveAnnotation: <T extends TextAnnotation>(annotation: T, container: HTMLElement) => T;

package/dist/src/utils/reviveSelector.d.ts

@@ -8,4 +8,4 @@ import { TextSelector } from '../model';
  *
  * @returns the revived selector
  */
-export declare const reviveSelector: (selector: TextSelector, container: HTMLElement) => TextSelector;
+export declare const reviveSelector: <T extends TextSelector>(selector: T, container: HTMLElement) => T;

package/dist/src/utils/reviveTarget.d.ts

@@ -1,2 +1,2 @@
 import { TextAnnotationTarget } from '../model';
-export declare const reviveTarget: (target: TextAnnotationTarget, container: HTMLElement) => TextAnnotationTarget;
+export declare const reviveTarget: <T extends TextAnnotationTarget = TextAnnotationTarget>(target: T, container: HTMLElement) => T;