@recogito/text-annotator 3.4.10 → 4.0.0

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-export * from './api';
-export * from './highlight';
 export * from './model';
-export * from './presence';
+export * from './rendering';
 export * from './state';
-export * from './utils';
-export * from './SelectionHandler';
-export * from './TextAnnotator';
-export * from './TextAnnotatorOptions';
+export * from './utils/annotation';
+export * from './utils/dom';
+export * from './utils/events';
+export * from './utils/highlight';
+export * from './selection-handler';
+export * from './text-annotator';
+export * from './text-annotator-options';
 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/index.d.ts

@@ -1 +1 @@
-export * from './TextAnnotation';
+export * from './text-annotation';

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

@@ -1,2 +1,2 @@
-export * from './W3CTextAnnotation';
-export * from './W3CTextFormatAdapter';
+export * from './w3c-text-annotation';
+export * from './w3c-text-format-adapter';

package/dist/model/w3c/{W3CTextFormatAdapter.d.ts → w3c-text-format-adapter.d.ts}

@@ -1,6 +1,6 @@
-import { type FormatAdapter, type ParseResult } from '@annotorious/core';
 import type { TextAnnotation } from '../core';
-import type { W3CTextAnnotation } from '../w3c';
+import type { W3CTextAnnotation } from './';
+import { type FormatAdapter, type ParseResult } from '@annotorious/core';
 export type W3CTextFormatAdapter<I extends TextAnnotation = TextAnnotation, E extends W3CTextAnnotation = W3CTextAnnotation> = FormatAdapter<I, E>;
 /**
  * @param source - the IRI of the annotated content

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

@@ -0,0 +1,31 @@
+import { type Unsubscribe } from 'nanoevents';
+import { type Filter, type ViewportState } from '@annotorious/core';
+import type { TextAnnotation } from '../model';
+import type { TextAnnotatorState } from '../state';
+import { type Highlight, type HighlightStyleExpression, type ViewportBounds } from './';
+/**
+ * The renderer runtime interface.
+ */
+export interface Renderer {
+    destroy(): void;
+    on: <E extends keyof RendererEvents>(event: E, callback: RendererEvents[E]) => Unsubscribe;
+    redraw(force?: boolean): void;
+    setStyle(style?: HighlightStyleExpression, id?: string): void;
+    setFilter(filter?: Filter<any>): void;
+    setVisible(visible: boolean): void;
+}
+export interface RendererEvents {
+    onRedraw(): void;
+}
+export type RendererFactory<T extends TextAnnotation> = (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
+ * BaseRenderer, which will handle common concerns.
+ */
+export interface Painter {
+    destroy(): void;
+    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;

package/dist/{highlight/HighlightStyle.d.ts → rendering/highlight-style.d.ts}

@@ -1,5 +1,6 @@
 import type { AnnotationState, Color, DrawingStyle } from '@annotorious/core';
-import type { TextAnnotation } from 'src/model';
+import type { TextAnnotation } from '../model';
+import type { Highlight } from './';
 export interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity'> {
     underlineStyle?: string;
     underlineColor?: Color;
@@ -9,3 +10,5 @@ export interface HighlightStyle extends Pick<DrawingStyle, 'fill' | 'fillOpacity
 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;
+export declare const getBackgroundColor: (style?: HighlightStyle) => string;
+export declare const computeStyle: (highlight: Highlight, style?: HighlightStyleExpression, z?: number) => HighlightStyle;

package/dist/{highlight/Highlight.d.ts → rendering/highlight.d.ts}

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

package/dist/rendering/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base-renderer';
+export * from './highlight';
+export * from './highlight-style';
+export * from './renderer-spans';
+export * from './viewport';

package/dist/rendering/renderer-css-highlight/css-highlight-renderer.d.ts

@@ -0,0 +1,7 @@
+import type { TextAnnotation } from '../../model';
+import { type Painter, type RendererFactory } from '../';
+/**
+ * EXPERIMENTAL!
+ */
+export declare const createCSSHighlightPainter: () => Painter;
+export declare const createCSSHighlightRenderer: RendererFactory<TextAnnotation>;

package/dist/rendering/renderer-css-highlight/index.d.ts

@@ -0,0 +1 @@
+export * from './css-highlight-renderer';

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

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

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

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

package/dist/selection-handler.d.ts

@@ -0,0 +1,12 @@
+import type { Filter, Lifecycle, User } from '@annotorious/core';
+import type { TextAnnotatorState } from './state';
+import type { TextAnnotation } from './model';
+import type { AnnotatingMode } from './text-annotator';
+import type { TextAnnotatorOptions } from './text-annotator-options';
+export declare const createSelectionHandler: <T extends TextAnnotation>(container: HTMLElement, state: TextAnnotatorState<TextAnnotation, any>, lifecycle: Lifecycle<TextAnnotation, any>, options: TextAnnotatorOptions<TextAnnotation, any>) => {
+    destroy: () => void;
+    setFilter: (filter?: Filter<any>) => Filter<any>;
+    setUser: (user?: User) => User;
+    setAnnotatingEnabled: (enabled: boolean) => void;
+    setAnnotatingMode: (mode?: AnnotatingMode) => AnnotatingMode;
+};

package/dist/state/index.d.ts

@@ -1,2 +1,2 @@
-export * from './TextAnnotationStore';
-export * from './TextAnnotatorState';
+export * from './text-annotation-store';
+export * from './text-annotator-state';

package/dist/state/{spatialTree.d.ts → spatial-tree.d.ts}

@@ -1,7 +1,7 @@
 import type { Store } from '@annotorious/core';
 import { type Unsubscribe } from 'nanoevents';
 import type { TextAnnotation, TextAnnotationTarget } from '../model';
-import type { AnnotationRects } from './TextAnnotationStore';
+import type { AnnotationRects } from '../state/text-annotation-store';
 interface IndexedHighlightRect {
     minX: number;
     minY: number;
@@ -19,7 +19,7 @@ export declare const createSpatialTree: <T extends TextAnnotation>(store: Store<
     all: () => IndexedHighlightRect[][];
     clear: () => void;
     getAt: (x: number, y: number, all?: boolean) => string[];
-    getAnnotationBounds: (id: string) => DOMRect;
+    getAnnotationBounds: (id: string) => DOMRect | undefined;
     getAnnotationRects: (id: string) => DOMRect[];
     getIntersecting: (minX: number, minY: number, maxX: number, maxY: number) => AnnotationRects<T>[];
     insert: (target: TextAnnotationTarget) => void;

package/dist/state/{TextAnnotationStore.d.ts → 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 { SpatialTreeEvents } from './spatialTree';
-export interface TextAnnotationStore<T extends TextAnnotation = TextAnnotation> extends Omit<Store<T>, 'addAnnotation' | 'bulkAddAnnotation'> {
+import type { SpatialTreeEvents } from '../state/spatial-tree';
+export interface TextAnnotationStore<T extends TextAnnotation = 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[];

package/dist/state/{TextAnnotatorState.d.ts → 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 { TextAnnotationStore } from './TextAnnotationStore';
-import type { TextAnnotatorOptions } from '../TextAnnotatorOptions';
-export interface TextAnnotatorState<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends AnnotatorState<I, E> {
+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'> {
     store: TextAnnotationStore<I>;
     selection: SelectionState<I, E>;
     hover: HoverState<I>;

package/dist/{TextAnnotatorOptions.d.ts → text-annotator-options.d.ts}

@@ -1,9 +1,8 @@
 import type { FormatAdapter, UserSelectActionExpression, User } from '@annotorious/core';
-import type { PresencePainterOptions } from './presence';
+import type { HighlightStyleExpression, RendererFactory } from './rendering';
 import type { TextAnnotation } from './model';
-import type { HighlightStyleExpression, RendererFactory } from './highlight';
 export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> {
-    adapter?: FormatAdapter<I, E> | null;
+    adapter?: FormatAdapter<I, E>;
     allowModifierSelect?: boolean;
     annotatingEnabled?: boolean;
     /**
@@ -23,13 +22,12 @@ export interface TextAnnotatorOptions<I extends TextAnnotation = TextAnnotation,
         verticalTolerance?: number;
     };
     offsetReferenceSelector?: string;
-    presence?: PresencePainterOptions;
-    renderer?: RendererType | RendererFactory;
+    renderer?: RendererType | RendererFactory<I>;
     selectionMode?: 'shortest' | 'all';
     style?: HighlightStyleExpression;
     user?: User;
     userSelectAction?: UserSelectActionExpression<E>;
 }
-export type RendererType = 'SPANS' | 'CANVAS' | 'CSS_HIGHLIGHTS';
+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>;

package/dist/text-annotator.css

@@ -1 +1 @@
-.r6o-canvas-highlight-layer{position:fixed;top:0;bottom:0;left:0;width:100vw;height:100vh;pointer-events:none}.r6o-canvas-highlight-layer.bg{mix-blend-mode:multiply;z-index:1}.r6o-annotatable .r6o-span-highlight-layer{position:absolute;top:0;left:0;width:100%;height:100%;mix-blend-mode:multiply;pointer-events:none;overflow:hidden;user-select:none;-webkit-user-select:none;z-index:1}.r6o-annotatable .r6o-span-highlight-layer.hidden{display:none}.r6o-annotatable .r6o-span-highlight-layer .r6o-annotation{position:absolute;display:block;border-style:solid;border-width:0;box-sizing:content-box}.r6o-presence-layer{left:0;position:fixed;top:0;bottom:0;width:100vw;pointer-events:none}html,body{overscroll-behavior-y:none}.r6o-annotatable{position:relative;-webkit-tap-highlight-color:transparent}.r6o-annotatable.no-focus-outline{outline:none}.hovered *{cursor:pointer}*::selection,::selection{background:#0080ff2e}::-moz-selection{background:#0080ff2e}
+.r6o-annotatable .r6o-span-highlight-layer{position:absolute;top:0;left:0;width:100%;height:100%;mix-blend-mode:multiply;pointer-events:none;overflow:hidden;user-select:none;-webkit-user-select:none;z-index:1}.r6o-annotatable .r6o-span-highlight-layer.hidden{display:none}.r6o-annotatable .r6o-span-highlight-layer .r6o-annotation{position:absolute;display:block;border-style:solid;border-width:0;box-sizing:content-box}html,body{overscroll-behavior-y:none}.r6o-annotatable{position:relative;-webkit-tap-highlight-color:transparent}.r6o-annotatable.no-focus-outline{outline:none}.hovered *{cursor:pointer}*::selection,::selection{background:#0080ff2e}::-moz-selection{background:#0080ff2e}

package/dist/{TextAnnotator.d.ts → text-annotator.d.ts}

@@ -1,13 +1,13 @@
-import type { Annotator } from '@annotorious/core';
-import type { HighlightStyleExpression } from './highlight';
+import { type Annotator } from '@annotorious/core';
+import type { HighlightStyleExpression, Renderer } from './rendering';
 import type { TextAnnotation } from './model';
 import { type TextAnnotatorState } from './state';
-import { type TextAnnotatorOptions } from './TextAnnotatorOptions';
-import './TextAnnotator.css';
-export interface TextAnnotator<I extends TextAnnotation = TextAnnotation, E extends unknown = TextAnnotation> extends Annotator<I, E> {
+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'> {
     element: HTMLElement;
-    setStyle(style: HighlightStyleExpression | undefined): void;
-    redraw(lazy?: boolean): void;
+    renderer: Renderer;
+    setStyle(style?: HighlightStyleExpression, id?: string): void;
     scrollIntoView(annotationOrId: I | string, scrollParentOrId?: string | Element): boolean;
     setAnnotatingEnabled(enabled?: boolean): void;
     setAnnotatingMode(mode?: AnnotatingMode): void;