@recogito/text-annotator 4.0.3-beta → 4.1.1

package/dist/model/core/text-annotation.d.ts

@@ -13,3 +13,15 @@ export interface TextSelector {
     range: Range;
     offsetReference?: HTMLElement;
 }
+export interface TextAnnotationLike extends Annotation {
+    target: TextAnnotationTargetLike;
+}
+export interface TextAnnotationTargetLike extends AnnotationTarget {
+    selector: TextSelectorLike[];
+}
+export interface TextSelectorLike {
+    id?: string;
+    quote: string;
+    range: Range;
+    offsetReference?: HTMLElement;
+}

package/dist/rendering/base-renderer.d.ts

@@ -1,6 +1,6 @@
 import { type Unsubscribe } from 'nanoevents';
 import { type Filter, type ViewportState } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
+import type { TextAnnotationLike } from '../model';
 import type { TextAnnotatorState } from '../state';
 import { type Highlight, type HighlightStyleExpression, type ViewportBounds } from './';
 /**
@@ -17,7 +17,7 @@ export interface Renderer {
 export interface RendererEvents {
     onRedraw(): void;
 }
-export type RendererFactory<T extends TextAnnotation> = (container: HTMLElement, state: TextAnnotatorState<T, any>, viewport: ViewportState) => Renderer;
+export type RendererFactory<T extends TextAnnotationLike> = (container: HTMLElement, state: TextAnnotatorState<T, any>, viewport: ViewportState) => Renderer;
 /**
  * A utility interface. Instead of implementing a Renderer from scratch,
  * implementers can simply implement a painter, and wrap it in the
@@ -28,4 +28,4 @@ export interface Painter {
     redraw(highlights: Highlight[], bounds: ViewportBounds, style?: HighlightStyleExpression, styleOverrides?: Map<string, HighlightStyleExpression>, force?: boolean): void;
     setVisible(visible: boolean): void;
 }
-export declare const createRenderer: <T extends TextAnnotatorState = TextAnnotatorState<TextAnnotation, any>>(painter: Painter, container: HTMLElement, state: T, viewport: ViewportState) => Renderer;
+export declare const createRenderer: <T extends TextAnnotatorState<TextAnnotationLike, any>>(painter: Painter, container: HTMLElement, state: T, viewport: ViewportState) => Renderer;

package/dist/rendering/highlight-style.d.ts

@@ -1,5 +1,5 @@
 import type { AnnotationState, Color, DrawingStyle } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
+import type { TextAnnotationLike } from '../model';
 import type { Highlight } from './';
 export interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity'> {
     underlineStyle?: string;
@@ -7,7 +7,7 @@ export interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity
     underlineOffset?: number;
     underlineThickness?: number;
 }
-export type HighlightStyleExpression = HighlightStyle | (<I extends TextAnnotation = TextAnnotation>(annotation: I, state: AnnotationState, zIndex?: number) => HighlightStyle | undefined);
+export type HighlightStyleExpression = HighlightStyle | (<I extends TextAnnotationLike = TextAnnotationLike>(annotation: I, state: AnnotationState, zIndex?: number) => HighlightStyle | undefined);
 export declare const DEFAULT_STYLE: HighlightStyle;
 export declare const DEFAULT_SELECTED_STYLE: HighlightStyle;
 export declare const getBackgroundColor: (style?: HighlightStyle) => string;

package/dist/rendering/highlight.d.ts

@@ -1,6 +1,6 @@
 import type { AnnotationState } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
+import type { TextAnnotationLike } from '../model';
 import type { AnnotationRects } from '../state';
-export interface Highlight extends AnnotationRects<TextAnnotation> {
+export interface Highlight extends AnnotationRects<TextAnnotationLike> {
     state: AnnotationState;
 }

package/dist/rendering/renderer-spans/spans-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { TextAnnotation } from '../../model';
+import type { TextAnnotationLike } from '../../model';
 import { type RendererFactory } from '../';
 import './spans-renderer.css';
-export declare const createSpansRenderer: RendererFactory<TextAnnotation>;
+export declare const createSpansRenderer: RendererFactory<TextAnnotationLike>;

package/dist/rendering/viewport.d.ts

@@ -1,5 +1,5 @@
 import type { ViewportState } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
+import type { TextAnnotationLike } from '../model';
 export interface ViewportBounds {
     top: number;
     left: number;
@@ -9,4 +9,4 @@ export interface ViewportBounds {
     maxY: number;
 }
 export declare const getViewportBounds: (container: HTMLElement) => ViewportBounds;
-export declare const trackViewport: (viewport: ViewportState) => (annotations: TextAnnotation[]) => void;
+export declare const trackViewport: (viewport: ViewportState) => (annotations: TextAnnotationLike[]) => void;

package/dist/state/spatial-tree.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from '@annotorious/core';
 import { type Unsubscribe } from 'nanoevents';
-import type { TextAnnotation, TextAnnotationTarget } from '../model';
+import type { TextAnnotationLike, TextAnnotationTarget } from '../model';
 import type { AnnotationRects } from '../state/text-annotation-store';
 interface IndexedHighlightRect {
     minX: number;
@@ -15,7 +15,7 @@ interface IndexedHighlightRect {
 export interface SpatialTreeEvents {
     recalculate(): void;
 }
-export declare const createSpatialTree: <T extends TextAnnotation>(store: Store<T>, container: HTMLElement, hMergeTolerance?: number, vMergeTolerance?: number) => {
+export declare const createSpatialTree: <T extends TextAnnotationLike>(store: Store<T>, container: HTMLElement, hMergeTolerance?: number, vMergeTolerance?: number) => {
     all: () => IndexedHighlightRect[][];
     clear: () => void;
     getAt: (x: number, y: number, all?: boolean) => string[];

package/dist/state/text-annotation-store.d.ts

@@ -1,8 +1,8 @@
 import type { Unsubscribe } from 'nanoevents';
 import type { Filter, Origin, Store } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
+import type { TextAnnotation, TextAnnotationLike } from '../model';
 import type { SpatialTreeEvents } from '../state/spatial-tree';
-export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotations' | 'bulkUpsertAnnotations'> {
+export interface TextAnnotationStore<T extends TextAnnotationLike = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotations' | 'bulkUpsertAnnotations'> {
     addAnnotation(annotation: T, origin?: Origin): boolean;
     bulkAddAnnotations(annotations: T[], replace: boolean, origin?: Origin): T[];
     bulkUpsertAnnotations(annotations: T[], origin?: Origin): T[];
@@ -16,7 +16,7 @@ export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation>
     recalculatePositions(): void;
     onRecalculatePositions(callback: SpatialTreeEvents['recalculate']): Unsubscribe;
 }
-export interface AnnotationRects<T extends TextAnnotation = TextAnnotation> {
+export interface AnnotationRects<T extends TextAnnotationLike = TextAnnotation> {
     annotation: T;
     rects: Rect[];
 }

package/dist/state/text-annotator-state.d.ts

@@ -1,9 +1,9 @@
 import type { ViewportState } from '@annotorious/core';
 import type { AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
-import type { TextAnnotation } from '../model';
+import type { TextAnnotation, TextAnnotationLike } from '../model';
 import type { TextAnnotationStore } from '../state/text-annotation-store';
 import type { TextAnnotatorOptions } from '../text-annotator-options';
-export interface TextAnnotatorState<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Omit<AnnotatorState<I, E>, 'store'> {
+export interface TextAnnotatorState<I extends TextAnnotationLike = TextAnnotation, E extends unknown = TextAnnotation> extends Omit<AnnotatorState<I, E>, 'store'> {
     store: TextAnnotationStore<I>;
     selection: SelectionState<I, E>;
     hover: HoverState<I>;

package/dist/text-annotator-options.d.ts

@@ -1,7 +1,7 @@
 import type { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/core';
 import type { HighlightStyleExpression, RendererFactory } from './rendering';
-import type { TextAnnotation } from './model';
-export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
+import type { TextAnnotation, TextAnnotationLike } from './model';
+export interface TextAnnotatorOptions<I extends TextAnnotationLike = TextAnnotation, E extends unknown = TextAnnotation> {
     adapter?: FormatAdapter<I, E>;
     allowModifierSelect?: boolean;
     annotatingEnabled?: boolean;
@@ -30,4 +30,4 @@ export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation,
 }
 export type RendererType = 'SPANS' | 'CSS_HIGHLIGHTS';
 export type DismissOnNotAnnotatableExpression = 'NEVER' | 'ALWAYS' | ((event: Event, container: HTMLElement) => boolean);
-export declare const fillDefaults: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(opts: TextAnnotatorOptions<I, E>, defaults: TextAnnotatorOptions<I, E>) => TextAnnotatorOptions<I, E>;
+export declare const fillDefaults: <I extends TextAnnotationLike = TextAnnotation, E extends unknown = TextAnnotation>(opts: TextAnnotatorOptions<I, E>, defaults: TextAnnotatorOptions<I, E>) => TextAnnotatorOptions<I, E>;

package/dist/text-annotator.d.ts

@@ -1,10 +1,10 @@
 import { type Annotator } from '@annotorious/core';
 import type { HighlightStyleExpression, Renderer } from './rendering';
-import type { TextAnnotation } from './model';
+import type { TextAnnotation, TextAnnotationLike } from './model';
 import { type TextAnnotatorState } from './state';
 import { type TextAnnotatorOptions } from './text-annotator-options';
 import './text-annotator.css';
-export interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Omit<Annotator<I, E>, 'setStyle' | 'state'> {
+export interface TextAnnotator<I extends TextAnnotationLike = TextAnnotation, E extends unknown = TextAnnotation> extends Omit<Annotator<I, E>, 'setStyle' | 'state'> {
     element: HTMLElement;
     renderer: Renderer;
     setStyle(style?: HighlightStyleExpression, id?: string): void;
@@ -14,4 +14,4 @@ export interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E exte
     state: TextAnnotatorState<I, E>;
 }
 export type AnnotatingMode = 'CREATE_NEW' | 'ADD_TO_CURRENT' | 'REPLACE_CURRENT';
-export declare const createTextAnnotator: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(container: HTMLElement, options?: TextAnnotatorOptions<I, E>) => TextAnnotator<I, E>;
+export declare const createTextAnnotator: <I extends TextAnnotationLike = TextAnnotationLike, E extends unknown = TextAnnotationLike>(container: HTMLElement, options?: TextAnnotatorOptions<I, E>) => TextAnnotator<I, E>;