@annotorious/core 3.0.0-pre-alpha-46 → 3.0.0-pre-alpha-48

package/package.json

@@ -1,34 +1,42 @@
 {
   "name": "@annotorious/core",
-  "version": "3.0.0-pre-alpha-46",
-  "description": "Experimental rewrite of Annotorious",
+  "version": "3.0.0-pre-alpha-48",
+  "description": "Annotorious core types and functions",
+  "author": "Rainer Simon",
+  "license": "BSD-3-Clause",
+  "homepage": "https://annotorious.github.io",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/annotorious/annotorious.git"
+  },
+  "bugs": {
+    "url": "https://github.com/annotorious/annotorious/issues"
+  },
+  "scripts": {
+    "build": "echo 'Skipping build in @annotorious/core package'",
+    "test": "vitest",
+    "coverage": "vitest run --coverage"
+  },
   "main": "src/index.ts",
   "types": "src/index.ts",
   "files": [
     "src"
   ],
-  "scripts": {
-    "build": "echo 'Skipping build in @annotorious/formats package'",
-    "test": "vitest",
-    "coverage": "vitest run --coverage"
-  },
-  "author": "Rainer Simon",
-  "license": "BSD-3-Clause",
   "devDependencies": {
     "@tsconfig/svelte": "^3.0.0",
-    "@types/deep-equal": "^1.0.1",
-    "@types/uuid": "^9.0.1",
-    "svelte": "^3.58.0",
+    "@types/deep-equal": "^1.0.2",
+    "@types/uuid": "^9.0.4",
+    "svelte": "^3.59.2",
     "typescript": "^4.9.5",
-    "vite": "^4.2.1",
-    "vite-plugin-dts": "^2.3.0",
-    "vitest": "^0.29.3"
+    "vite": "^4.4.9",
+    "vite-plugin-dts": "^3.6.0",
+    "vitest": "^0.34.6"
   },
   "dependencies": {
     "dequal": "^2.0.3",
-    "nanoevents": "^7.0.1",
-    "nanoid": "^4.0.1",
-    "uuid": "^9.0.0"
+    "nanoevents": "^8.0.0",
+    "nanoid": "^5.0.1",
+    "uuid": "^9.0.1"
   }
 }

package/src/lifecycle/Lifecycle.ts

@@ -1,28 +1,29 @@
 import { dequal } from 'dequal/lite';
-import type { Annotation, FormatAdapter, W3CAnnotation } from '../model';
+import type { Annotation, FormatAdapter } from '../model';
 import { Origin } from '../state';
 import type { HoverState, SelectionState, Store, ViewportState } from '../state';
 import type { LifecycleEvents } from './LifecycleEvents';
 
-export type Lifecycle<T extends Annotation> = ReturnType<typeof createLifecyleObserver<T>>;
+export type Lifecycle<I extends Annotation, E extends unknown> = 
+  ReturnType<typeof createLifecyleObserver<I, E>>;
 
-export const createLifecyleObserver = <T extends Annotation, A extends unknown = W3CAnnotation>(
-  store: Store<T>,
-  selectionState: SelectionState<T>, 
-  hoverState: HoverState<T>,
+export const createLifecyleObserver = <I extends Annotation, E extends unknown>(
+  store: Store<I>,
+  selectionState: SelectionState<I>, 
+  hoverState: HoverState<I>,
   viewportState?: ViewportState,
-  adapter?: FormatAdapter<T, A>
+  adapter?: FormatAdapter<I, E>
 ) => {
-  const observers = new Map<string, LifecycleEvents<A>[keyof LifecycleEvents<T>][]>();
+  const observers = new Map<string, LifecycleEvents<E>[keyof LifecycleEvents<E>][]>();
 
   // The currently selected annotations, in the state when they were selected 
-  let initialSelection: T[] = [];
+  let initialSelection: I[] = [];
 
   let currentHover: string | undefined;
 
   let idleTimeout: ReturnType<typeof setTimeout>;
 
-  const on = <E extends keyof LifecycleEvents<T>>(event: E, callback: LifecycleEvents<A>[E]) => {
+  const on = <T extends keyof LifecycleEvents<E>>(event: T, callback: LifecycleEvents<E>[T]) => {
     if (observers.has(event)) {
       observers.get(event).push(callback);
     } else {
@@ -30,7 +31,7 @@ export const createLifecyleObserver = <T extends Annotation, A extends unknown =
     }
   }
 
-  const off = <E extends keyof LifecycleEvents<T>>(event: E, callback: LifecycleEvents<A>[E]) => {
+  const off = <T extends keyof LifecycleEvents<E>>(event: T, callback: LifecycleEvents<E>[T]) => {
     const callbacks = observers.get(event);
     if (callbacks) {
       const idx = callbacks.indexOf(callback);
@@ -39,7 +40,7 @@ export const createLifecyleObserver = <T extends Annotation, A extends unknown =
     }
   }
 
-  const emit = (event: keyof LifecycleEvents<T>, arg0: T | T[], arg1: T = null) => {
+  const emit = (event: keyof LifecycleEvents<E>, arg0: I | I[], arg1: I = null) => {
     if (observers.has(event)) {
       setTimeout(() => {
         observers.get(event).forEach(callback => { 
@@ -49,9 +50,9 @@ export const createLifecyleObserver = <T extends Annotation, A extends unknown =
             
             const serialized1 = arg1 && adapter.serialize(arg1);
 
-            callback(serialized0 as A & A[], serialized1); 
+            callback(serialized0 as E & E[], serialized1); 
           } else {
-            callback(arg0 as A & A[], arg1 as unknown as A);  
+            callback(arg0 as E & E[], arg1 as unknown as E);  
           }
         });
       }, 1);

package/src/model/Annotator.ts

@@ -0,0 +1,51 @@
+import type { Annotation } from './Annotation';
+import type { User } from './User';
+import type { PresenceProvider } from '../presence';
+import type { HoverState, SelectionState, Store, ViewportState } from '../state';
+import type { LifecycleEvents } from '../lifecycle';
+import type { Formatter } from './Formatter';
+
+/**
+ * Base annotator interface.
+ * I ... internal core data model 
+ * E ... external adapted representation
+ */
+export interface Annotator<I extends Annotation = Annotation, E extends unknown = Annotation> {
+
+  addAnnotation(annotation: E): void;
+
+  getAnnotationById(id: string): E | undefined;
+
+  getAnnotations(): E[];
+
+  getUser(): User;
+
+  loadAnnotations(url: string): Promise<E[]>;
+
+  setAnnotations(annotations: E[]): void;
+
+  setFormatter(formatter: Formatter): void;
+
+  setUser(user: User): void;
+
+  setPresenceProvider?(provider: PresenceProvider): void;
+
+  on<T extends keyof LifecycleEvents<E>>(event: T, callback: LifecycleEvents<E>[T]): void;
+
+  off<T extends keyof LifecycleEvents<E>>(event: T, callback: LifecycleEvents<E>[T]): void;
+
+  state: AnnotatorState<I>;
+
+}
+
+export interface AnnotatorState<A extends Annotation> {
+
+  store: Store<A>;
+
+  selection: SelectionState<A>;
+
+  hover: HoverState<A>;
+
+  viewport: ViewportState;
+
+}

package/src/model/FormatAdapter.ts

@@ -1,4 +1,4 @@
-import type { Annotation } from './core/Annotation';
+import type { Annotation } from './Annotation';
 
 export interface FormatAdapter<A extends Annotation, T extends unknown> {
 

package/src/model/index.ts

@@ -1,3 +1,6 @@
-export * from './core';
 export * from './w3c';
-export * from './FormatAdapter';
+export * from './Annotation';
+export * from './Annotator';
+export * from './FormatAdapter';
+export * from './Formatter';
+export * from './User';

package/src/model/w3c/W3CAnnotation.ts

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
-import type { AnnotationBody } from '../core';
+import type { AnnotationBody } from '../Annotation';
 
 export interface W3CAnnotation {
 
@@ -67,7 +67,9 @@ export const parseBodies = (
   purpose: b.purpose,
   value: b.value,
   created: b.created,
-  creator: b.creator ? { ...b.creator } : undefined
+  creator: b.creator ? 
+    typeof b.creator === 'object' ? { ...b.creator }: b.creator :
+    undefined
 }));
 
 

package/src/state/SvelteStore.ts

@@ -1,8 +1,26 @@
-import type { Annotation } from '../model';
-import { createStore } from './Store';
+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; 
+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
@@ -11,11 +29,9 @@ type Subscriber = <T extends Annotation>(annotation: T[]) => void;
  * convenient for everyone using Svelte, as well as for the
  * basic (Svelte-based) Annotorious standard implementation.
  */
-export const createSvelteStore = <T extends Annotation>() => {
-
-  const store = createStore<T>();
+export const toSvelteStore = <T extends Annotation>(store: Store<T>): SvelteStore<T> => {
 
-  const subscribe = (onChange: Subscriber) => {
+  const subscribe = (onChange: Subscriber<T>) => {
 
     // Register a store observer on behalf of the subscriber
     const shim = (event: StoreChangeEvent<T>) => onChange(event.state);

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: { value: string, [key: string]: any },
+  created?: Date,
+  creator?: User
+): AnnotationBody => ({
+  id: uuidv4(),
+  annotation: annotation.id,
+  created: created || new Date(),
+  creator,
+  ...payload
+});

package/src/utils/index.ts

@@ -1,4 +1,3 @@
-export * from './bodyUtils';
-export * from './collaboratorUtils';
+export * from './annotationUtils';
 export * from './diffAnnotations';
 

package/src/model/core/Annotator.ts

@@ -1,47 +0,0 @@
-import type { Annotation } from './Annotation';
-import type { User } from './User';
-import type { PresenceProvider } from '../../presence';
-import type { HoverState, SelectionState, Store, ViewportState } from '../../state';
-import type { LifecycleEvents } from '../../lifecycle';
-import type { W3CAnnotation } from '../w3c';
-import type { Formatter } from './Formatter';
-
-export interface Annotator<A extends Annotation = Annotation, T extends unknown = W3CAnnotation> {
-
-  addAnnotation(annotation: T): void;
-
-  getAnnotationById(id: string): T | undefined;
-
-  getAnnotations(): T[];
-
-  getUser(): User;
-
-  loadAnnotations(url: string): Promise<T[]>;
-
-  setAnnotations(annotations: T[]): void;
-
-  setFormatter(formatter: Formatter): void;
-
-  setUser(user: User): void;
-
-  setPresenceProvider?(provider: PresenceProvider): void;
-
-  on<E extends keyof LifecycleEvents<T>>(event: E, callback: LifecycleEvents<T>[E]): void;
-
-  off<E extends keyof LifecycleEvents<T>>(event: E, callback: LifecycleEvents<T>[E]): void;
-
-  state: AnnotatorState<A>;
-
-}
-
-export interface AnnotatorState<A extends Annotation> {
-
-  store: Store<A>;
-
-  selection: SelectionState<A>;
-
-  hover: HoverState<A>;
-
-  viewport: ViewportState;
-
-}

package/src/model/core/index.ts

@@ -1,4 +0,0 @@
-export * from './Annotation';
-export * from './Annotator';
-export * from './Formatter';
-export * from './User';

package/src/utils/bodyUtils.ts

@@ -1,23 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import type { Annotation, AnnotationBody, User } from '../model';
-
-export interface HasValue {
-
-  value: string;
-
-  [key:string]: any;
-
-}
-
-export const createBody = (
-  annotation: Annotation, 
-  payload: HasValue,
-  created?: Date,
-  creator?: User
-): AnnotationBody => ({
-  id: uuidv4(),
-  annotation: annotation.id,
-  created: created || new Date(),
-  creator,
-  ...payload
-});

package/src/utils/collaboratorUtils.ts

@@ -1,19 +0,0 @@
-import type { Annotation, User } from '../model';
-
-/**
- * Returns all users listed as creators or updaters in any parts of this
- * annotation.
- */
-export const getCollaborators = (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
-}