@recogito/text-annotator 3.3.2 → 3.4.0

package/dist/SelectionHandler.d.ts

@@ -0,0 +1,10 @@
+import { type Filter, type User } from '@annotorious/core';
+import type { TextAnnotatorState } from './state';
+import type { TextAnnotation } from './model';
+import type { TextAnnotatorOptions } from './TextAnnotatorOptions';
+export declare const createSelectionHandler: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, options: TextAnnotatorOptions<TextAnnotation, unknown>) => {
+    destroy: () => void;
+    setFilter: (filter?: Filter) => Filter;
+    setUser: (user?: User) => User;
+    setAnnotatingEnabled: (enabled: boolean) => void;
+};

package/dist/TextAnnotator.d.ts

@@ -0,0 +1,15 @@
+import type { Annotator } from '@annotorious/core';
+import { type HighlightStyleExpression } from './highlight';
+import { type TextAnnotatorState } from './state';
+import type { TextAnnotation } from './model';
+import { type TextAnnotatorOptions } from './TextAnnotatorOptions';
+import './TextAnnotator.css';
+export interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Annotator<I, E> {
+    element: HTMLElement;
+    setStyle(style: HighlightStyleExpression | undefined): void;
+    redraw(lazy?: boolean): void;
+    scrollIntoView(annotationOrId: I | string, scrollParentOrId?: string | Element): boolean;
+    setAnnotatingEnabled: (enabled: boolean) => void;
+    state: TextAnnotatorState<I, E>;
+}
+export declare const createTextAnnotator: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(container: HTMLElement, options?: TextAnnotatorOptions<I, E>) => TextAnnotator<I, E>;

package/dist/TextAnnotatorOptions.d.ts

@@ -0,0 +1,34 @@
+import type { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/core';
+import type { PresencePainterOptions } from './presence';
+import type { TextAnnotation } from './model';
+import type { HighlightStyleExpression } from './highlight';
+export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
+    adapter?: FormatAdapter<I, E> | null;
+    annotatingEnabled?: boolean;
+    /**
+     * Determines whether an active selection should be dismissed
+     * when a user ends their interaction (click, selection)
+     * on a non-annotatable element.
+     * - NEVER - don't dismiss the selection, ignore the action.
+     * - ALWAYS - dismiss the selection.
+     * - function - a custom matcher that takes an event and container as arguments.
+     *              Returns `true` if the selection should be dismissed.
+     *
+     * @defaut NEVER
+     */
+    dismissOnNotAnnotatable?: DismissOnNotAnnotatableExpression;
+    mergeHighlights?: {
+        horizontalTolerance?: number;
+        verticalTolerance?: number;
+    };
+    offsetReferenceSelector?: string;
+    presence?: PresencePainterOptions;
+    renderer?: RendererType;
+    selectionMode?: 'shortest' | 'all';
+    style?: HighlightStyleExpression;
+    user?: User;
+    userSelectAction?: UserSelectActionExpression<E>;
+}
+export type RendererType = 'SPANS' | 'CANVAS' | '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>;

package/dist/api/index.d.ts

@@ -0,0 +1 @@
+export * from './scrollIntoView';

package/dist/api/scrollIntoView.d.ts

@@ -0,0 +1,3 @@
+import type { TextAnnotationStore } from '../state';
+import type { TextAnnotation } from '../model';
+export declare const scrollIntoView: <I extends TextAnnotation = TextAnnotation>(container: HTMLElement, store: TextAnnotationStore<I>) => <E extends Element = Element>(annotationOrId: string | I, scrollParentOrId?: string | E) => boolean;

package/dist/highlight/Highlight.d.ts

@@ -0,0 +1,5 @@
+import type { AnnotationState } from '@annotorious/core';
+import type { AnnotationRects } from '../state';
+export interface Highlight extends AnnotationRects {
+    state: AnnotationState;
+}

package/dist/highlight/HighlightPainter.d.ts

@@ -0,0 +1,11 @@
+import type { Highlight } from './Highlight';
+import type { HighlightStyle, HighlightStyleExpression } from './HighlightStyle';
+import type { ViewportBounds } from './viewport';
+export interface HighlightPainter {
+    clear(): void;
+    destroy(): void;
+    paint(highlight: Highlight, viewportBounds: ViewportBounds): HighlightStyle;
+    reset(): void;
+}
+/** Helper **/
+export declare const paint: (highlight: Highlight, viewportBounds: ViewportBounds, style?: HighlightStyleExpression, painter?: HighlightPainter, zIndex?: number) => HighlightStyle;

package/dist/highlight/HighlightStyle.d.ts

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

package/dist/highlight/baseRenderer.d.ts

@@ -0,0 +1,20 @@
+import type { Filter, ViewportState } from '@annotorious/core';
+import type { TextAnnotatorState } from '../state';
+import { type ViewportBounds } from './viewport';
+import type { HighlightPainter } from './HighlightPainter';
+import type { Highlight } from './Highlight';
+import type { HighlightStyleExpression } from './HighlightStyle';
+export interface RendererImplementation {
+    destroy(): void;
+    redraw(highlights: Highlight[], bounds: ViewportBounds, style?: HighlightStyleExpression, painter?: HighlightPainter, lazy?: boolean): void;
+    setVisible(visible: boolean): void;
+}
+export interface Renderer {
+    destroy(): void;
+    redraw(force?: boolean): void;
+    setStyle(style?: HighlightStyleExpression): void;
+    setFilter(filter?: Filter): void;
+    setPainter(painter?: HighlightPainter): void;
+    setVisible(visible: boolean): void;
+}
+export declare const createBaseRenderer: <T extends TextAnnotatorState = TextAnnotatorState>(container: HTMLElement, state: T, viewport: ViewportState, renderer: RendererImplementation) => Renderer;

package/dist/highlight/canvas/canvasRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { ViewportState } from '@annotorious/core';
+import type { TextAnnotatorState } from '../../state';
+import type { TextAnnotation } from 'src/model';
+import './canvasRenderer.css';
+export declare const createCanvasRenderer: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => import("../baseRenderer").Renderer;

package/dist/highlight/canvas/index.d.ts

@@ -0,0 +1 @@
+export * from './canvasRenderer';

package/dist/highlight/highlights/highlightsRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { ViewportState } from '@annotorious/core';
+import type { TextAnnotatorState } from 'src/state';
+import { type RendererImplementation } from '../baseRenderer';
+import type { TextAnnotation } from 'src/model';
+export declare const createRenderer: () => RendererImplementation;
+export declare const createHighlightsRenderer: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => import("../baseRenderer").Renderer;

package/dist/highlight/highlights/index.d.ts

@@ -0,0 +1 @@
+export * from './highlightsRenderer';

package/dist/highlight/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Highlight';
+export * from './HighlightStyle';
+export * from './HighlightPainter';
+export * from './canvas';
+export * from './highlights';
+export * from './span';

package/dist/highlight/span/color.d.ts

@@ -0,0 +1,2 @@
+import { type HighlightStyle } from '../HighlightStyle';
+export declare const getBackgroundColor: (style?: HighlightStyle) => string;

package/dist/highlight/span/index.d.ts

@@ -0,0 +1 @@
+export * from './spansRenderer';

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

@@ -0,0 +1,5 @@
+import type { ViewportState } from '@annotorious/core';
+import type { TextAnnotation } from '../../model';
+import type { TextAnnotatorState } from '../../state';
+import './spansRenderer.css';
+export declare const createSpansRenderer: (container: HTMLElement, state: TextAnnotatorState<TextAnnotation, unknown>, viewport: ViewportState) => import("../baseRenderer").Renderer;

package/dist/highlight/viewport.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './api';
+export * from './highlight';
+export * from './model';
+export * from './state';
+export * from './utils';
+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, ViewportState, W3CAnnotation, W3CAnnotationBody, W3CAnnotationTarget } from '@annotorious/core';
+export { createBody, Origin, UserSelectAction } from '@annotorious/core';

package/dist/model/core/TextAnnotation.d.ts

@@ -0,0 +1,15 @@
+import type { Annotation, AnnotationTarget } from '@annotorious/core';
+export interface TextAnnotation extends Annotation {
+    target: TextAnnotationTarget;
+}
+export interface TextAnnotationTarget extends AnnotationTarget {
+    selector: TextSelector[];
+}
+export interface TextSelector {
+    id?: string;
+    quote: string;
+    start: number;
+    end: number;
+    range: Range;
+    offsetReference?: HTMLElement;
+}

package/dist/model/core/index.d.ts

@@ -0,0 +1 @@
+export * from './TextAnnotation';

package/dist/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core';
+export * from './w3c';

package/dist/model/w3c/W3CTextAnnotation.d.ts

@@ -0,0 +1,34 @@
+import type { W3CAnnotation, W3CAnnotationTarget } from '@annotorious/core';
+export interface W3CTextAnnotation extends W3CAnnotation {
+    target: W3CTextAnnotationTarget | W3CTextAnnotationTarget[];
+    stylesheet?: W3CAnnotationStylesheet;
+}
+export interface W3CTextAnnotationTarget extends W3CAnnotationTarget {
+    selector: W3CTextSelector | W3CTextSelector[];
+    styleClass?: string;
+    scope?: string;
+}
+/**
+ * Matches the `Text Quote Selector` spec
+ * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
+ */
+export interface W3CTextQuoteSelector {
+    type: 'TextQuoteSelector';
+    exact: string;
+    prefix?: string;
+    suffix?: string;
+}
+/**
+ * Matches the `Text Position Selector` spec
+ * @see https://www.w3.org/TR/annotation-model/#text-position-selector
+ */
+export interface W3CTextPositionSelector {
+    type: 'TextPositionSelector';
+    start: number;
+    end: number;
+}
+export type W3CTextSelector = W3CTextQuoteSelector | W3CTextPositionSelector;
+export type W3CAnnotationStylesheet = string | {
+    type: 'CssStylesheet';
+    value: string;
+};

package/dist/model/w3c/W3CTextFormatAdapter.d.ts

@@ -0,0 +1,12 @@
+import { type FormatAdapter, type ParseResult } from '@annotorious/core';
+import type { TextAnnotation } from '../core';
+import type { W3CTextAnnotation } from '../w3c';
+export type W3CTextFormatAdapter<I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation> = FormatAdapter<I, E>;
+/**
+ * @param source - the IRI of the annotated content
+ * @param container - the HTML container of the annotated content,
+ *                    Required to locate the content's `range` within the DOM
+ */
+export declare const W3CTextFormat: <I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation>(source: string, container?: HTMLElement) => W3CTextFormatAdapter<I, E>;
+export declare const parseW3CTextAnnotation: <I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation>(annotation: E) => ParseResult<I>;
+export declare const serializeW3CTextAnnotation: <I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation>(annotation: I, source: string, container?: HTMLElement) => E;

package/dist/model/w3c/index.d.ts

@@ -0,0 +1,2 @@
+export * from './W3CTextAnnotation';
+export * from './W3CTextFormatAdapter';

package/dist/presence/PresencePainter.d.ts

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

package/dist/presence/PresencePainterOptions.d.ts

@@ -0,0 +1,3 @@
+export interface PresencePainterOptions {
+    font?: string;
+}

package/dist/presence/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PresencePainter';
+export * from './PresencePainterOptions';

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

@@ -1,3 +1,2 @@
 export declare const whitespaceOrEmptyRegex: RegExp;
-export declare const isRangeWhitespaceOrEmpty: (range: Range) => boolean;
-export declare const isNodeWhitespaceOrEmpty: (node: Node) => boolean;
+export declare const isWhitespaceOrEmpty: (range: Range) => boolean;

package/dist/state/TextAnnotationStore.d.ts

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

package/dist/state/TextAnnotatorState.d.ts

@@ -0,0 +1,12 @@
+import type { ViewportState } from '@annotorious/core';
+import type { AnnotatorState, SelectionState, HoverState } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { TextAnnotationStore } from './TextAnnotationStore';
+import type { TextAnnotatorOptions } from '../TextAnnotatorOptions';
+export interface TextAnnotatorState<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends AnnotatorState<I, E> {
+    store: TextAnnotationStore<I>;
+    selection: SelectionState<I, E>;
+    hover: HoverState<I>;
+    viewport: ViewportState;
+}
+export declare const createTextAnnotatorState: <I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation>(container: HTMLElement, opts: TextAnnotatorOptions<I, E>) => TextAnnotatorState<I, E>;

package/dist/state/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TextAnnotationStore';
+export * from './TextAnnotatorState';

package/dist/state/spatialTree.d.ts

@@ -0,0 +1,28 @@
+import type { Store } from '@annotorious/core';
+import type { TextAnnotation, TextAnnotationTarget } from '../model';
+import type { AnnotationRects } from './TextAnnotationStore';
+interface IndexedHighlightRect {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    annotation: {
+        id: string;
+        rects: DOMRect[];
+    };
+}
+export declare const createSpatialTree: <T extends TextAnnotation>(store: Store<T>, container: HTMLElement, hMergeTolerance?: number, vMergeTolerance?: number) => {
+    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<T>[];
+    insert: (target: TextAnnotationTarget) => void;
+    recalculate: () => void;
+    remove: (target: TextAnnotationTarget) => void;
+    set: (targets: TextAnnotationTarget[], replace?: boolean) => void;
+    size: () => number;
+    update: (target: TextAnnotationTarget) => void;
+};
+export {};