@annotorious/core 3.0.0-rc.2 → 3.0.0-rc.20

package/src/state/Selection.ts

@@ -1,113 +0,0 @@
-import { writable } from 'svelte/store';
-import type {  Annotation } from '../model';
-import type { Store } from './Store';
-   
-export type Selection = {
-
-  selected: { id: string, editable?: boolean }[],
-
-  pointerEvent?: PointerEvent;
-
-}
-
-export type SelectionState<T extends Annotation> = ReturnType<typeof createSelectionState<T>>;
-
-export enum PointerSelectAction {
-
-  EDIT = 'EDIT', // Make annotation target(s) editable on pointer select
-  
-  SELECT = 'SELECT',  // Just select, but don't make editable
-
-  NONE = 'NONE' // Click won't select - annotation is completely inert
-
-}
-
-const EMPTY: Selection = { selected: [] };
-
-export const createSelectionState = <T extends Annotation>(
-  store: Store<T>,
-  selectAction: PointerSelectAction | ((a: Annotation) => PointerSelectAction) = PointerSelectAction.EDIT
-) => {
-  const { subscribe, set } = writable<Selection>(EMPTY);
-
-  let currentSelection: Selection = EMPTY;
-
-  subscribe(updated => currentSelection = updated);
-
-  const clear = () => set(EMPTY);
-
-  const isEmpty = () => currentSelection.selected?.length === 0;
-
-  const isSelected = (annotationOrId: T | string) => {
-    if (currentSelection.selected.length === 0)
-      return false;
-
-    const id = typeof annotationOrId === 'string' ? annotationOrId : annotationOrId.id;
-    return currentSelection.selected.some(i => i.id === id);
-  }
-
-  // TODO enable CTRL select
-  const clickSelect = (id: string, pointerEvent: PointerEvent) => {
-    const annotation = store.getAnnotation(id);
-    if (annotation) {
-      const action = onPointerSelect(annotation, selectAction);
-      if (action === PointerSelectAction.EDIT)
-        set({ selected: [{ id, editable: true }], pointerEvent }); 
-      else if (action === PointerSelectAction.SELECT)
-        set({ selected: [{ id }], pointerEvent }); 
-      else
-        set({ selected: [], pointerEvent });
-    } else {
-      console.warn('Invalid selection: ' + id);
-    }
-  }
-
-  const setSelected = (idOrIds: string | string[], editable: boolean = true) => {
-    const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
-
-    // Remove invalid
-    const annotations = 
-      ids.map(id => store.getAnnotation(id)).filter(a => a); 
-
-    set({ selected: annotations.map(({ id }) => ({ id, editable })) });
-    
-    if (annotations.length !== ids.length)
-      console.warn('Invalid selection', idOrIds);
-  }
-
-  const removeFromSelection = (ids: string[]) => {
-    if (currentSelection.selected.length === 0)
-      return false;
-
-    const { selected } = currentSelection;
-
-    // Checks which of the given annotations are actually in the selection
-    const toRemove = selected.filter(({ id  }) => ids.includes(id))
-
-    if (toRemove.length > 0)
-      set({ selected: selected.filter(({ id }) => !ids.includes(id)) });
-  }
-
-  // Track store delete and update events
-  store.observe(({ changes }) =>
-    removeFromSelection(changes.deleted.map(a => a.id)));
-
-  return { 
-    clear, 
-    clickSelect, 
-    get selected() { return currentSelection ? [...currentSelection.selected ] : null},
-    get pointerEvent() { return currentSelection ? currentSelection.pointerEvent : null },
-    isEmpty, 
-    isSelected, 
-    setSelected, 
-    subscribe 
-  };
-
-}
-
-export const onPointerSelect = (
-  annotation: Annotation, 
-  action?: PointerSelectAction | ((a: Annotation) => PointerSelectAction)
-): PointerSelectAction => (typeof action === 'function') ?
-    (action(annotation) || PointerSelectAction.EDIT) : 
-    (action || PointerSelectAction.EDIT);

package/src/state/Store.ts

@@ -1,327 +0,0 @@
-import type { Annotation, AnnotationBody, AnnotationTarget } from '../model';
-import { diffAnnotations } from '../utils';
-import { Origin, shouldNotify, type Update, type ChangeSet } from './StoreObserver';
-import type { StoreObserver, StoreChangeEvent, StoreObserveOptions } from './StoreObserver';
-
-// Shorthand
-type AnnotationBodyIdentifier = { id: string, annotation: string }; 
-
-export type Store<T extends Annotation> = ReturnType<typeof createStore<T>>;
-
-const isAnnotation = <T extends Annotation>(arg: any): arg is T => arg.id !== undefined;
-
-export const createStore = <T extends Annotation>() => {
-
-  const annotationIndex = new Map<string, T>();
-
-  const bodyIndex = new Map<string, string>();
-
-  const observers: StoreObserver<T>[] = [];
-
-  const observe = (onChange: { (event: StoreChangeEvent<T>): void }, options: StoreObserveOptions = {}) =>
-    observers.push({ onChange, options });
-
-  const unobserve = (onChange: { (event: StoreChangeEvent<T>): void }) => {
-    const idx = observers.findIndex(observer => observer.onChange == onChange);
-    if (idx > -1)
-      observers.splice(idx, 1);
-  }
-
-  const emit = (origin: Origin, changes: ChangeSet<T>) => {
-    const event: StoreChangeEvent<T> = {
-      origin,
-      changes: {
-        created: changes.created || [],
-        updated: changes.updated || [],
-        deleted: changes.deleted || []
-      },
-      state: [...annotationIndex.values()]
-    };
-
-    observers.forEach(observer => {
-      if (shouldNotify(observer, event))
-        observer.onChange(event);
-    });
-  }
-
-  const addAnnotation = (annotation: T, origin = Origin.LOCAL) => {
-    const existing = annotationIndex.get(annotation.id);
-
-    if (existing) {
-      throw Error(`Cannot add annotation ${annotation.id} - exists already`);
-    } else {
-      annotationIndex.set(annotation.id, annotation);
-
-      annotation.bodies.forEach(b => bodyIndex.set(b.id, annotation.id));
-      emit(origin, { created: [annotation] });
-    }
-  }
-
-  const updateAnnotation = (arg1: string | T, arg2: T | Origin = Origin.LOCAL, arg3 = Origin.LOCAL) => {
-    const origin: Origin = isAnnotation(arg2) ? arg3 : arg2;
-
-    const updated: T = typeof arg1 === 'string' ? arg2 as T : arg1;
-
-    const oldId: string = typeof arg1 === 'string' ? arg1 : arg1.id;
-    const oldValue = annotationIndex.get(oldId);
-
-    if (oldValue) {
-      const update: Update<T> = diffAnnotations(oldValue, updated);
-
-      if (oldId === updated.id) {
-        annotationIndex.set(oldId, updated);
-      } else {
-        annotationIndex.delete(oldId);
-        annotationIndex.set(updated.id, updated);
-      }
-
-      oldValue.bodies.forEach(b => bodyIndex.delete(b.id));
-      updated.bodies.forEach(b => bodyIndex.set(b.id, updated.id));
-
-      emit(origin, { updated: [update] })
-    } else {
-      throw Error(`Cannot update annotation ${oldId} - does not exist`);
-    }
-  }
-
-  const addBody = (body: AnnotationBody, origin = Origin.LOCAL) => {
-    const oldValue = annotationIndex.get(body.annotation);
-    if (oldValue) {
-      const newValue = { 
-        ...oldValue,
-        bodies: [ ...oldValue.bodies, body ]
-      };
-
-      annotationIndex.set(oldValue.id, newValue);
-
-      bodyIndex.set(body.id, newValue.id);
-
-      const update: Update<T> = {
-        oldValue, newValue, bodiesCreated: [ body ]
-      };
-
-      emit(origin, { updated: [update] });
-    } else {
-      console.warn(`Attempt to add body to missing annotation: ${body.annotation}`);
-    }
-  }
-
-  const all = () => [...annotationIndex.values()];
-
-  const clear = (origin = Origin.LOCAL) => { 
-    const all = [...annotationIndex.values()];
-
-    annotationIndex.clear();
-    bodyIndex.clear();
-
-    emit(origin, { deleted: all });
-  }
-
-  const bulkAddAnnotation = (annotations: T[], replace = true, origin = Origin.LOCAL) => {
-    if (replace) {
-      // Delete existing first
-      const deleted = [...annotationIndex.values()];
-      annotationIndex.clear();
-      bodyIndex.clear();
-
-      annotations.forEach(annotation => {
-        annotationIndex.set(annotation.id, annotation);
-        annotation.bodies.forEach(b => bodyIndex.set(b.id, annotation.id));
-      });
-
-      emit(origin, { created: annotations, deleted });
-    } else {
-      // Don't allow overwriting of existing annotations
-      const existing = annotations.reduce((all, next) => {
-        const existing = annotationIndex.get(next.id);
-        return existing ? [...all, existing ] : all;
-      }, []);
-
-      if (existing.length > 0)
-        throw Error(`Bulk insert would overwrite the following annotations: ${existing.map(a => a.id).join(', ')}`);
-
-      annotations.forEach(annotation => {
-        annotationIndex.set(annotation.id, annotation);
-        annotation.bodies.forEach(b => bodyIndex.set(b.id, annotation.id));
-      });
-
-      emit(origin, { created: annotations });
-    }
-  }
-
-  const deleteOneAnnotation = (annotationOrId: T | string) => {
-    const id = typeof annotationOrId === 'string' ? annotationOrId : annotationOrId.id;
-
-    const existing = annotationIndex.get(id);
-    if (existing) {
-      annotationIndex.delete(id);
-      existing.bodies.forEach(b => bodyIndex.delete(b.id));
-      return existing;
-    } else {
-      console.warn(`Attempt to delete missing annotation: ${id}`);
-    }
-  }
-
-  const deleteAnnotation = (annotationOrId: T | string, origin = Origin.LOCAL) => {
-    const deleted = deleteOneAnnotation(annotationOrId);
-    if (deleted)
-      emit(origin, { deleted: [ deleted  ]});
-  }
-
-  const bulkDeleteAnnotation = (annotationsOrIds: (T | string)[], origin = Origin.LOCAL) => {
-    const deleted = annotationsOrIds.reduce((deleted, arg) => {
-      const existing = deleteOneAnnotation(arg);
-      return existing ? [...deleted, existing] : deleted;
-    }, [] as T[]);
-
-    if (deleted.length > 0)
-      emit(origin, { deleted });
-  }
- 
-  const deleteBody = (body: AnnotationBodyIdentifier, origin = Origin.LOCAL) => {
-    const oldAnnotation = annotationIndex.get(body.annotation);
-
-    if (oldAnnotation) {
-      const oldBody = oldAnnotation.bodies.find(b => b.id === body.id);
-
-      if (oldBody) {
-        bodyIndex.delete(oldBody.id);
-
-        const newAnnotation = {
-          ...oldAnnotation,
-          bodies: oldAnnotation.bodies.filter(b => b.id !== body.id)
-        };
-
-        annotationIndex.set(oldAnnotation.id, newAnnotation);
-
-        const update: Update<T> = {
-          oldValue: oldAnnotation, newValue: newAnnotation, bodiesDeleted: [oldBody]
-        };
-
-        emit(origin, { updated: [update] });
-      } else {
-        console.warn(`Attempt to delete missing body ${body.id} from annotation ${body.annotation}`);
-      }
-    } else {
-      console.warn(`Attempt to delete body from missing annotation ${body.annotation}`);
-    }
-  }
-
-  const getAnnotation = (id: string): T | undefined => {
-    const a = annotationIndex.get(id);
-    return a ? {...a} : undefined;
-  }
-
-  const getBody = (id: string): AnnotationBody | undefined => {
-    const annotationId = bodyIndex.get(id);
-    if (annotationId) {
-      const annotation = getAnnotation(annotationId);
-      const body = annotation.bodies.find(b => b.id === id);
-      if (body) {
-        return body;
-      } else {
-        console.error(`Store integrity error: body ${id} in index, but not in annotation`);
-      }
-    } else {
-      console.warn(`Attempt to retrieve missing body: ${id}`);
-    }
-  }
-
-  const updateOneBody = (oldBodyId: AnnotationBodyIdentifier, newBody: AnnotationBody) => {
-    if (oldBodyId.annotation !== newBody.annotation)
-      throw 'Annotation integrity violation: annotation ID must be the same when updating bodies';
-
-    const oldAnnotation = annotationIndex.get(oldBodyId.annotation);
-    if (oldAnnotation) {
-      const oldBody = oldAnnotation.bodies.find(b => b.id === oldBodyId.id);
-
-      const newAnnotation = { 
-        ...oldAnnotation,
-        bodies: oldAnnotation.bodies.map(b => b.id === oldBody.id ? newBody : b)
-      };
-
-      annotationIndex.set(oldAnnotation.id, newAnnotation);
-
-      if (oldBody.id !== newBody.id) {
-        bodyIndex.delete(oldBody.id);
-        bodyIndex.set(newBody.id, newAnnotation.id);
-      }
-
-      return {
-        oldValue: oldAnnotation, 
-        newValue: newAnnotation,
-        bodiesUpdated: [{ oldBody, newBody }]
-      }
-    } else {
-      console.warn(`Attempt to add body to missing annotation ${oldBodyId.annotation}`);
-    }
-  }
-
-  const updateBody = (oldBodyId: AnnotationBodyIdentifier, newBody: AnnotationBody, origin = Origin.LOCAL) => {
-    const update = updateOneBody(oldBodyId, newBody);
-    emit(origin, { updated: [ update ]} );
-  }
-
-  const bulkUpdateBodies = (bodies: AnnotationBody[], origin = Origin.LOCAL) => {
-    const updated = bodies.map(b => updateOneBody({ id: b.id, annotation: b.annotation }, b));
-    emit(origin, { updated });
-  }
-
-  const updateOneTarget = (target: AnnotationTarget): Update<T> => {
-    const oldValue = annotationIndex.get(target.annotation);
-    
-    if (oldValue) {
-      const newValue = { 
-        ...oldValue, 
-        target: {
-          ...oldValue.target,
-          ...target 
-        }
-      };
-
-      annotationIndex.set(oldValue.id, newValue);
-
-      return {
-        oldValue, newValue, targetUpdated: { 
-          oldTarget: oldValue.target,
-          newTarget: target
-        }
-      };
-    } else {
-      console.warn(`Attempt to update target on missing annotation: ${target.annotation}`);
-    }
-  }
-
-  const updateTarget = (target: AnnotationTarget, origin = Origin.LOCAL) => {
-    const update = updateOneTarget(target);
-    if (update)
-      emit(origin, { updated: [ update ]} );
-  }
-
-  const bulkUpdateTargets = (targets: AnnotationTarget[], origin = Origin.LOCAL) => {
-    const updated = targets.map(updateOneTarget).filter(val => val);
-    if (updated.length > 0)
-      emit(origin, { updated });
-  }
-
-	return {
-    addAnnotation,
-    addBody,
-    all,
-    bulkAddAnnotation,
-    bulkDeleteAnnotation,
-    bulkUpdateBodies,
-    bulkUpdateTargets,
-    clear,
-    deleteAnnotation,
-    deleteBody,
-    getAnnotation,
-    getBody,
-    observe,
-    unobserve,
-    updateAnnotation,
-    updateBody,
-    updateTarget
-	};
-
-}

package/src/state/StoreObserver.ts

@@ -1,149 +0,0 @@
-import type { Annotation, AnnotationBody, AnnotationTarget } from '../model';
-
-/** Interface for listening to changes in the annotation store **/
-export interface StoreObserver<T extends Annotation> { 
-
-  onChange: { (event: StoreChangeEvent<T>): void };
-
-  options: StoreObserveOptions;
-
-}
-
-/** A change event fired when the store state changes **/
-export interface StoreChangeEvent<T extends Annotation> {
-
-  origin: Origin;
-
-  changes: ChangeSet<T>;
-
-  state: T[];
-
-}
-
-export interface ChangeSet<T extends Annotation> {
-
-  created?: T[];
-
-  deleted?: T[];
-
-  updated?: Update<T>[];
-
-}
-
-export interface Update<T extends Annotation> {
-
-  oldValue: T;
-
-  newValue: T;
-
-  bodiesCreated?: AnnotationBody[];
-
-  bodiesDeleted?: AnnotationBody[];
-
-  bodiesUpdated?: Array<{ oldBody: AnnotationBody, newBody: AnnotationBody }>;
-
-  targetUpdated?: { oldTarget: AnnotationTarget, newTarget: AnnotationTarget};
-
-}
-
-/** Options to control which events the observer wants to get notified about **/
-export interface StoreObserveOptions {
-
-  // Observe changes on targets, bodies or both?
-  ignore?: Ignore;
-
-  // Observe changes on one more specific annotations
-  annotations?: string | string[];
-
-  // Observer changes only for a specific origin
-  origin?: Origin
-
-}
-
-/** Allows the observer to ignore certain event types **/
-export enum Ignore { 
-
-  // Don't notify this observer for changes that involve bodies only
-  BODY_ONLY = 'BODY_ONLY',
-
-  // Don't notify for changes on targets only
-  TARGET_ONLY = 'TARGET_ONLY'
-
-}
-
-/** Allows the observer to listen only for events that originated locally or from a remote source **/
-export enum Origin { 
-  
-  LOCAL = 'LOCAL', 
-  
-  REMOTE = 'REMOTE' 
-
-}
-
-/** Tests if this observer should be notified about this event **/
-export const shouldNotify = <T extends Annotation>(observer: StoreObserver<T>, event: StoreChangeEvent<T>) => {
-  const { changes, origin } = event;
-
-  const isRelevantOrigin = 
-    !observer.options.origin || observer.options.origin === origin;
-
-  if (!isRelevantOrigin)
-    return false;
-
-  if (observer.options.ignore) {
-    const { ignore } = observer.options;
-
-    // Shorthand
-    const has = (arg: any[]) => arg?.length > 0;
-
-    const hasAnnotationChanges =
-      has(changes.created) || has(changes.deleted);
-
-    if (!hasAnnotationChanges) {
-      const hasBodyChanges =
-        changes.updated?.some(u => has(u.bodiesCreated) || has(u.bodiesDeleted) || has(u.bodiesUpdated));
-    
-      const hasTargetChanges = 
-        changes.updated?.some(u => u.targetUpdated);
-
-      if (ignore === Ignore.BODY_ONLY && hasBodyChanges && !hasTargetChanges)
-        return false;
-
-      if (ignore === Ignore.TARGET_ONLY && hasTargetChanges && !hasBodyChanges)
-        return false;
-    }
-  }
-
-  if (observer.options.annotations) {
-    // This observer has a filter set on specific annotations - check affected
-    const affectedAnnotations = new Set([
-      ...changes.created.map(a => a.id),
-      ...changes.deleted.map(a => a.id),
-      ...changes.updated.map(({ oldValue }) => oldValue.id)
-    ]);
-
-    const observed = Array.isArray(observer.options.annotations) ?
-      observer.options.annotations : [ observer.options.annotations ];
-
-    return Boolean(observed.find(id => affectedAnnotations.has(id)));
-  } else {
-    return true;
-  }
-
-}
-
-export const mergeChanges = <T extends Annotation>(event: StoreChangeEvent<T>, toMerge: StoreChangeEvent<T>) => {
-  if (event.origin !== toMerge.origin)
-    throw 'Cannot merge events from different origins';
-
-  return {
-    origin: toMerge.origin,
-    changes: {
-      // TODO filter created that were deleted in the same go
-      created: [...(event.changes.created || []), ...(toMerge.changes.created || []) ],
-      deleted: [...(event.changes.deleted || []), ...(toMerge.changes.deleted || []) ] 
-      // TODO merge updates
-    },
-    state: toMerge.state
-  }
-}

package/src/state/SvelteStore.ts

@@ -1,54 +0,0 @@
-import type { Annotation, Annotator, AnnotatorState } from '../model';
-import type { Store } from './Store';
-import type { StoreChangeEvent } from './StoreObserver';
-
-type Subscriber<T extends Annotation> = (annotation: T[]) => void; 
-
-export interface SvelteStore<T extends Annotation> extends Store<T> {
-
-  subscribe(onChange: Subscriber<T>): void;
-
-}
-
-export interface SvelteAnnotatorState<T extends Annotation> extends AnnotatorState<T> {
-
-  store: SvelteStore<T>
-
-}
-
-export interface SvelteAnnotator<T extends Annotation> extends Annotator<T> {
-
-  state: SvelteAnnotatorState<T>
-
-}
-
-/** 
- * A simple wrapper around the event-based store implementation
- * that adds a Svelte shim, for use with the reactive '$' notation.
- * Other frameworks might not actually need this. But it's pretty
- * convenient for everyone using Svelte, as well as for the
- * basic (Svelte-based) Annotorious standard implementation.
- */
-export const toSvelteStore = <T extends Annotation>(store: Store<T>): SvelteStore<T> => {
-
-  const subscribe = (onChange: Subscriber<T>) => {
-
-    // Register a store observer on behalf of the subscriber
-    const shim = (event: StoreChangeEvent<T>) => onChange(event.state);
-    store.observe(shim);
-
-    // Immediately call the subscriber function with the
-    // current store value, according to the Svelte contract.
-    // https://stackoverflow.com/questions/68220955/how-does-svelte-unsubscribe-actually-work
-    onChange(store.all());
-
-    // Return the unsubscribe function
-    return () => store.unobserve(shim);
-  }
-
-  return {
-    ...store,
-    subscribe
-  }
-
-}

package/src/state/Viewport.ts

@@ -1,14 +0,0 @@
-import { writable } from 'svelte/store';
-
-export type ViewportState = ReturnType<typeof createViewportState>;
-
-export const createViewportState = () => {
-
-  const { subscribe, set } = writable<string[]>([]);
-
-  return { 
-    subscribe, 
-    set
-  };
-
-}

package/src/utils/annotationUtils.ts

@@ -1,33 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import type { Annotation, AnnotationBody, User } from '../model';
-
-/**
- * Returns all users listed as creators or updaters in any parts of this
- * annotation.
- */
-export const getContributors = (annotation: Annotation): User[] => {
-  const { creator, updatedBy } = annotation.target;
-
-  const bodyCollaborators = annotation.bodies.reduce((users, body) =>  (
-    [...users, body.creator, body.updatedBy]
-  ), [] as User[]);
-
-  return [
-    creator,
-    updatedBy,
-    ...bodyCollaborators
-  ].filter(u => u); // Remove undefined
-}
-
-export const createBody = (
-  annotation: Annotation, 
-  payload: { [key: string]: any },
-  created?: Date,
-  creator?: User
-): AnnotationBody => ({
-  id: uuidv4(),
-  annotation: annotation.id,
-  created: created || new Date(),
-  creator,
-  ...payload
-});