@annotorious/core 3.0.0-rc.21 → 3.0.0-rc.4

package/src/state/UndoStack.ts

@@ -0,0 +1,143 @@
+import { createNanoEvents, type Unsubscribe } from 'nanoevents';
+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 <T extends Annotation> {
+
+  canRedo(): boolean;
+
+  canUndo(): boolean;
+
+  destroy(): void;
+
+  on<E extends keyof UndoStackEvents<T>>(event: E, callback: UndoStackEvents<T>[E]): Unsubscribe;
+
+  undo(): void;
+
+  redo(): void;
+
+}
+
+export interface UndoStackEvents <T extends Annotation> {
+
+  redo(change: ChangeSet<T>): void;
+
+  undo(change: ChangeSet<T>): void;
+
+}
+
+export const createUndoStack = <T extends Annotation>(store: Store<T>): UndoStack<T> => {
+
+  const emitter = createNanoEvents<UndoStackEvents<T>>();
+
+  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);
+
+      emitter.emit('undo', changeStack[pointer]);
+
+      pointer -= 1;
+    }
+  }
+
+  const canUndo = () => pointer > -1;
+
+  const redo = () => {
+    if (changeStack.length - 1 > pointer) {
+      muteEvents = true;
+
+      const { created, updated, deleted } = changeStack[pointer + 1];
+
+      redoCreated(created);
+      redoUpdated(updated);
+      redoDeleted(deleted);
+
+      emitter.emit('redo', changeStack[pointer + 1]);
+
+      pointer += 1;
+    }
+  }
+
+  const canRedo = () => changeStack.length - 1 > pointer;
+
+  const destroy = () => store.unobserve(onChange);
+
+  const on = <E extends keyof UndoStackEvents<T>>(event: E, callback: UndoStackEvents<T>[E]) => 
+    emitter.on(event, callback);
+
+  return {
+    canRedo,
+    canUndo,
+    destroy,
+    on,
+    redo,
+    undo
+  }
+
+}

package/src/state/Viewport.ts

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

package/{dist/state/index.d.ts → src/state/index.ts}

@@ -4,5 +4,4 @@ export * from './Store';
 export * from './StoreObserver';
 export * from './SvelteStore';
 export * from './UndoStack';
-export * from './Viewport';
-//# sourceMappingURL=index.d.ts.map
+export * from './Viewport';

package/src/utils/annotationUtils.ts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,39 @@
+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/{dist/utils/index.d.ts → src/utils/index.ts}

@@ -1,3 +1,3 @@
 export * from './annotationUtils';
 export * from './diffAnnotations';
-//# sourceMappingURL=index.d.ts.map
+

package/src/vite-env.d.ts

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