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

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/UndoStack.ts

@@ -1,112 +0,0 @@
-import type { Annotation } from '../model';
-import type { Store } from './Store';
-import { Origin } from './StoreObserver';
-import { mergeChanges, type ChangeSet, type StoreChangeEvent, type Update } from './StoreObserver';
-
-// Duration with fast successive changes get merged 
-// with the last event in the stack, rather than getting stacked
-// as a new undo/redo step.
-const DEBOUNCE = 250;
-
-export interface UndoStack {
-
-  destroy(): void;
-
-  undo(): void;
-
-  redo(): void;
-
-}
-
-export const createUndoStack = <T extends Annotation>(store: Store<T>): UndoStack => {
-
-  const changeStack: ChangeSet<T>[] = [];
-
-  let pointer = -1;
-
-  let muteEvents = false;
-
-  let lastEvent = 0;
-
-  const onChange = (event: StoreChangeEvent<T>) => {
-    if (!muteEvents) {
-      const { changes } = event;
-
-      const now = performance.now();
-
-      if (now - lastEvent > DEBOUNCE) {
-        // Put this change on the stack...
-        changeStack.splice(pointer + 1);
-        changeStack.push(changes);
-
-        // ...and update the pointer
-        pointer = changeStack.length - 1;
-      } else {
-        // Merge this change with the last in the stack
-        const last = changeStack.length - 1;
-        changeStack[last] = mergeChanges(changeStack[last], changes);
-      }
-
-      lastEvent = now;
-    }
-
-    muteEvents = false;
-  }
-
-  store.observe(onChange, { origin: Origin.LOCAL });
-
-  const undoCreated = (created: T[]) => 
-    created?.length > 0 && store.bulkDeleteAnnotation(created);
-
-  const redoCreated = (created: T[]) =>
-    created?.length > 0 && store.bulkAddAnnotation(created, false);
-
-  const undoUpdated = (updated: Update<T>[]) =>
-    updated?.length > 0 && store.bulkUpdateAnnotation(updated.map(({ oldValue }) => oldValue));
-      
-  const redoUpdated = (updated: Update<T>[]) =>
-    updated?.length > 0 && store.bulkUpdateAnnotation(updated.map(({ newValue }) => newValue));
-
-  const undoDeleted = (deleted: T[]) => 
-    deleted?.length > 0 && store.bulkAddAnnotation(deleted, false);
-
-  const redoDeleted = (deleted: T[]) =>
-    deleted?.length > 0 && store.bulkDeleteAnnotation(deleted);
-
-  const undo = () => {
-    if (pointer > -1) {
-      muteEvents = true;
-
-      const { created, updated, deleted} = changeStack[pointer];
-
-      undoCreated(created);
-      undoUpdated(updated);
-      undoDeleted(deleted);
-
-      pointer -= 1;
-    }
-  }
-
-  const redo = () => {
-    if (changeStack.length - 1 > pointer) {
-      muteEvents = true;
-
-      const { created, updated, deleted } = changeStack[pointer + 1];
-
-      redoCreated(created);
-      redoUpdated(updated);
-      redoDeleted(deleted);
-
-      pointer += 1;
-    }
-  }
-
-  const destroy = () => store.unobserve(onChange);
-
-  return {
-    destroy,
-    redo,
-    undo
-  }
-
-}

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
-});

package/src/utils/diffAnnotations.ts

@@ -1,39 +0,0 @@
-import { dequal } from 'dequal/lite';
-import type { Update } from '../state';
-import type { Annotation } from '../model';
-
-const getAddedBodies = (oldValue: Annotation, newValue: Annotation) => {
-  const oldBodyIds = new Set(oldValue.bodies.map(b => b.id));
-  return newValue.bodies.filter(b => !oldBodyIds.has(b.id));
-}
-
-const getRemovedBodies = (oldValue: Annotation, newValue: Annotation) => {
-  const newBodyIds = new Set(newValue.bodies.map(b => b.id));
-  return oldValue.bodies.filter(b => !newBodyIds.has(b.id));
-}
-
-const getChangedBodies = (oldValue: Annotation, newValue: Annotation) => 
-  newValue.bodies
-    .map(newBody => {
-      const oldBody = oldValue.bodies.find(b => b.id === newBody.id);
-      return { newBody, oldBody: oldBody && !dequal(oldBody, newBody) ? oldBody : undefined }
-    })
-    .filter(({ oldBody }) => oldBody);
-
-const hasTargetChanged = (oldValue: Annotation, newValue: Annotation) => 
-  !dequal(oldValue.target, newValue.target);
-
-export const diffAnnotations = <T extends Annotation = Annotation>(oldValue: T, newValue: T): Update<T> => {
-  const bodiesCreated = getAddedBodies(oldValue, newValue);
-  const bodiesDeleted = getRemovedBodies(oldValue, newValue);
-  const bodiesUpdated = getChangedBodies(oldValue, newValue);
-
-  return {
-    oldValue, 
-    newValue,
-    bodiesCreated: bodiesCreated.length > 0 ? bodiesCreated : undefined,
-    bodiesDeleted: bodiesDeleted.length > 0 ? bodiesDeleted : undefined,
-    bodiesUpdated: bodiesUpdated.length > 0 ? bodiesUpdated : undefined,
-    targetUpdated: hasTargetChanged(oldValue, newValue) ? { oldTarget: oldValue.target, newTarget: newValue.target } : undefined
-  }
-}

package/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />