@annotorious/core 3.0.0-rc.3 → 3.0.0-rc.30

package/src/presence/PresentUser.ts

@@ -1,10 +0,0 @@
-import type { User } from '../model';
-import type { Appearance } from './Appearance';
-
-export interface PresentUser extends User {
-
-  presenceKey: string;
-
-  appearance: Appearance
-
-}

package/src/state/Hover.ts

@@ -1,34 +0,0 @@
-import { writable } from 'svelte/store';
-import type { Annotation } from '../model';
-import type { Store } from './Store';
-
-export type HoverState<T extends Annotation> = ReturnType<typeof createHoverState<T>>;
-
-export const createHoverState = <T extends Annotation>(store: Store<T>) => {
-
-  const { subscribe, set } = writable<string>(null);
-
-  let currentHover: string = null;
-
-  subscribe(updated => currentHover = updated);
-
-  // Track store delete and update events
-  store.observe(( { changes }) => {    
-    if (currentHover) {
-      const isDeleted = changes.deleted.some(a => a.id === currentHover);
-      if (isDeleted)
-        set(null);
-    
-      const updated = changes.updated.find(({ oldValue }) => oldValue.id === currentHover);
-      if (updated)
-        set(updated.newValue.id);
-    }
-  });
-
-  return { 
-    get current() { return currentHover },
-    subscribe, 
-    set 
-  };
-
-}

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,344 +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 updateOneAnnotation = (arg1: string | T, arg2?: T | Origin) => {
-    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));
-
-      return update;
-    } else {
-      console.warn(`Cannot update annotation ${oldId} - does not exist`);
-    }
-  }
-  
-  const updateAnnotation = (arg1: string | T, arg2: T | Origin = Origin.LOCAL, arg3 = Origin.LOCAL) => {
-    const origin: Origin = isAnnotation(arg2) ? arg3 : arg2;
-
-    const update = updateOneAnnotation(arg1, arg2);
-    if (update)
-      emit(origin, { updated: [update] })
-  }
-
-  const bulkUpdateAnnotation = (annotations: T[], origin = Origin.LOCAL) => {
-    const updated = annotations.reduce((updated, annotation) => {
-      const u = updateOneAnnotation(annotation);
-      return u ? [...updated, u] : updated;
-    }, [] as Update<T>[]);
-
-    if (updated.length > 0)
-      emit(origin, { updated });
-  }
-
-  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,
-    bulkUpdateAnnotation,
-    bulkUpdateBodies,
-    bulkUpdateTargets,
-    clear,
-    deleteAnnotation,
-    deleteBody,
-    getAnnotation,
-    getBody,
-    observe,
-    unobserve,
-    updateAnnotation,
-    updateBody,
-    updateTarget
-	};
-
-}

package/src/state/StoreObserver.ts

@@ -1,194 +0,0 @@
-import type { Annotation, AnnotationBody, AnnotationTarget } from '../model';
-import { diffAnnotations } from '../utils';
-
-/** 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>(changes: ChangeSet<T>, toMerge: ChangeSet<T>) => {
-
-  const previouslyCreatedIds = new Set((changes.created || []).map(a => a.id));
-  const previouslyUpdatedIds = new Set((changes.updated || []).map(({ newValue })=> newValue.id));
-
-  const createdIds = new Set((toMerge.created || []).map(a => a.id));
-  const deletedIds = new Set((toMerge.deleted || []).map(a => a.id));
-  const updatedIds = new Set((toMerge.updated || []).map(({ oldValue }) => oldValue.id));
-
-  // Updates that will be merged into create or previous update events
-  const mergeableUpdates = new Set((toMerge.updated || [])
-    .filter(({ oldValue }) => previouslyCreatedIds.has(oldValue.id) || previouslyUpdatedIds.has(oldValue.id))
-    .map(({ oldValue }) => oldValue.id ));
-
-  // * created *
-  // - drop created that were then deleted
-  // - merge any updates on created
-  // - append newly created
-  const created = [
-    ...(changes.created || [])
-      .filter(a => !deletedIds.has(a.id))
-      .map(a => updatedIds.has(a.id) 
-        ? toMerge.updated.find(({ oldValue }) => oldValue.id === a.id).newValue
-        : a),
-    ...(toMerge.created || [])
-  ];
-
-  // * deleted *
-  // - drop deleted that were later re-created (redo action!)
-  // - append newly deleted, but remove any that delete annotations 
-  //   that were created in the same round
-  const deleted = [
-    ...(changes.deleted || [])
-      .filter(a => !createdIds.has(a.id)),
-    ...(toMerge.deleted || []) 
-      .filter(a => !previouslyCreatedIds.has(a.id))
-  ] 
-
-  // * updated *
-  // - drop updates on deleted annotations
-  // - merge any updates that override previous ones
-  // - append new updates, but remove any that were merged
-  const updated = [
-    ...(changes.updated || [])
-      .filter(({ newValue }) => !deletedIds.has(newValue.id))
-      .map(update => {
-        const { oldValue, newValue } = update;
-        if (updatedIds.has(newValue.id)) {
-          const updated = toMerge.updated.find(u => u.oldValue.id === newValue.id).newValue;
-          return diffAnnotations(oldValue, updated);
-        } else {
-          return update;
-        }
-      }),
-    ...(toMerge.updated || []).filter(({ oldValue }) => !mergeableUpdates.has(oldValue.id))
-  ]
-
-  return { created, deleted, updated };
-}