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

package/src/model/Annotation.ts

@@ -1,57 +0,0 @@
-import type { User } from './User';
-
-export interface Annotation {
-
-  id: string;
-
-  target: AnnotationTarget;
-
-  bodies: AnnotationBody[];
-
-  properties?: {
-
-    [key: string]: any;
-
-  }
-
-}
-
-export interface AnnotationTarget {
-
-  annotation: string;
-
-  selector: AbstractSelector;
-
-  creator?: User;
-
-  created?: Date;
-
-  updatedBy?: User;
-
-  updated?: Date;
-
-}
-
-export interface AbstractSelector { }
-
-export interface AnnotationBody {
-
-  id: string;
-
-  annotation: string;
-
-  type?: string;
-
-  purpose?: string;
-
-  value?: string;
-
-  creator?: User;
-
-  created?: Date;
-
-  updatedBy?: User;
-
-  updated?: Date;
-
-}

package/src/model/Annotator.ts

@@ -1,154 +0,0 @@
-import type { Annotation } from './Annotation';
-import type { User } from './User';
-import type { PresenceProvider } from '../presence';
-import { Origin, type HoverState, type SelectionState, type Store, type ViewportState } from '../state';
-import type { LifecycleEvents } from '../lifecycle';
-import { parseAll, type FormatAdapter } from './FormatAdapter';
-import type { DrawingStyle } from './DrawingStyle';
-import type { Filter } from './Filter';
-
-/**
- * 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;
-
-  clearAnnotations(): void;
-
-  destroy(): void;
-
-  getAnnotationById(id: string): E | undefined;
-
-  getAnnotations(): E[];
-
-  getUser(): User;
-
-  loadAnnotations(url: string): Promise<E[]>;
-
-  removeAnnotation(arg: E | string): E;
-
-  setAnnotations(annotations: E[]): void;
-
-  setFilter(filter: Filter): void;
-
-  setPresenceProvider?(provider: PresenceProvider): void;
-
-  setSelected(arg?: string | string[]): void;
-
-  setStyle(arg: DrawingStyle | ((annotation: I) => DrawingStyle) | undefined): void;
-
-  setUser(user: User): void;
-
-  updateAnnotation(annotation: E): E;
-  
-  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;
-
-}
-
-export const createBaseAnnotator = <I extends Annotation, E extends unknown>(
-  store: Store<I>, 
-  adapter?: FormatAdapter<I, E>
-) => {
-
-  const addAnnotation = (annotation: E) => {
-    if (adapter) {
-      const { parsed, error } = adapter.parse(annotation);
-      if (parsed) {
-        store.addAnnotation(parsed, Origin.REMOTE);
-      } else {
-        console.error(error);
-      }
-    } else {
-      store.addAnnotation(annotation as unknown as I, Origin.REMOTE);
-    }
-  }
-
-  const clearAnnotations = () => store.clear();
-
-  const getAnnotationById = (id: string): E | undefined => {
-    const annotation = store.getAnnotation(id);
-    return (adapter && annotation) ?
-      adapter.serialize(annotation) as E : annotation as unknown as E;
-  }
-
-  const getAnnotations = () =>
-    (adapter ? store.all().map(adapter.serialize) : store.all()) as E[];
-
-  const loadAnnotations = (url: string) =>
-    fetch(url)
-      .then((response) => response.json())
-      .then((annotations) => {
-        setAnnotations(annotations);
-        return annotations;
-      });
-
-  const removeAnnotation = (arg: E | string): E => {
-    if (typeof arg === 'string') {
-      const annotation = store.getAnnotation(arg);
-      store.deleteAnnotation(arg);
-
-      return adapter ? adapter.serialize(annotation) : annotation as unknown as E;
-    } else {
-      const annotation = adapter ? adapter.parse(arg).parsed : (arg as unknown as I);
-      store.deleteAnnotation(annotation);
-      return arg;
-    }
-  }
-
-  const setAnnotations = (annotations: E[]) => {
-    if (adapter) {
-      const { parsed, failed } = parseAll(adapter)(annotations);
-
-      if (failed.length > 0)
-        console.warn(`Discarded ${failed.length} invalid annotations`, failed);
-
-      store.bulkAddAnnotation(parsed, true, Origin.REMOTE);
-    } else {
-      store.bulkAddAnnotation(annotations as unknown as I[], true, Origin.REMOTE);
-    }
-  }
-
-  const updateAnnotation = (updated: E): E => {
-    if (adapter) {
-      const crosswalked = adapter.parse(updated).parsed;
-      const previous = adapter.serialize(store.getAnnotation(crosswalked.id));
-      store.updateAnnotation(crosswalked);
-      return previous;
-    } else {
-      const previous = store.getAnnotation((updated as unknown as I).id);
-      store.updateAnnotation(updated as unknown as I);
-      return previous as unknown as E;
-    }
-  }
-
-  return { 
-    addAnnotation,
-    clearAnnotations,
-    getAnnotationById,
-    getAnnotations,
-    loadAnnotations,
-    removeAnnotation,
-    setAnnotations,
-    updateAnnotation
-  }
-
-}

package/src/model/FormatAdapter.ts

@@ -1,36 +0,0 @@
-import type { Annotation } from './Annotation';
-
-export interface FormatAdapter<A extends Annotation, T extends unknown> {
-
-  parse(serialized: T): ParseResult<A>;
-
-  serialize(core: A): T;
-
-}
-
-export interface ParseResult<A extends Annotation> {
-
-  parsed?: A;
-  
-  error?: Error;
-
-}
-
-export const serializeAll = 
-  <A extends Annotation, T extends unknown>(adapter: FormatAdapter<A, T>) =>
-    (annotations: A[]) => annotations.map(a => adapter.serialize(a));
-
-export const parseAll = 
-  <A extends Annotation, T extends unknown>(adapter: FormatAdapter<A, T>) =>
-    (serialized: T[]) => serialized.reduce((result, next) => {
-      const { parsed, error } = adapter.parse(next);
-
-      return error ? {
-        parsed: result.parsed,
-        failed: [...result.failed, next ]
-      } : {
-        parsed: [...result.parsed, parsed ],
-        failed: result.failed
-      }
-    }, { parsed: [], failed: [] });
-  

package/src/model/User.ts

@@ -1,19 +0,0 @@
-import { customAlphabet } from 'nanoid';
-
-export interface User {
-
-  id: string;
-
-  isGuest?: boolean;
-
-  name?: string;
-
-  avatar?: string;
-
-}
-
-export const createAnonymousGuest = () => {
-  const nanoid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_', 20);
-  
-  return { isGuest: true, id: nanoid() }
-}

package/src/model/W3CAnnotation.ts

@@ -1,118 +0,0 @@
-import type { AnnotationBody } from './Annotation';
-
-export interface W3CAnnotation {
-
-  '@context': 'http://www.w3.org/ns/anno.jsonld';
-
-  type: 'Annotation';
-
-  id: string;
-
-  body: W3CAnnotationBody | W3CAnnotationBody[]
-
-  target: W3CAnnotationTarget | W3CAnnotationTarget[];
-
-  [key: string]: any;
-
-}
-
-export interface W3CAnnotationBody {
-
-  id?: string;
-
-  type?: string;
-
-  purpose?: string;
-
-  value?: string;
-
-  source?: string;
-
-  created?: Date;
-
-  creator?: {
-
-    type?: string;
-
-    id: string;
-
-    name?: string;
-
-  };
-
-}
-
-export interface W3CAnnotationTarget {
-
-  source: string;
-
-  selector?: W3CSelector | W3CSelector[];
-
-}
-
-export interface W3CSelector {
-
-  type: string;
-
-  conformsTo?: string;
-
-  value: string;
-}
-
-// https://stackoverflow.com/questions/6122571/simple-non-secure-hash-function-for-javascript
-const hashCode = (obj: Object): string => {
-  const str = JSON.stringify(obj);
-
-  let hash = 0;
-
-  for (let i = 0, len = str.length; i < len; i++) {
-      let chr = str.charCodeAt(i);
-      hash = (hash << 5) - hash + chr;
-      hash |= 0; // Convert to 32bit integer
-  }
-
-  return `${hash}`;
-}
-
-/**
- * Helper to crosswalk the W3C annotation body to a list of core AnnotationBody objects.
- */
-export const parseW3CBodies = (
-  body: W3CAnnotationBody | W3CAnnotationBody[], 
-  annotationId: string
-): AnnotationBody[] => (Array.isArray(body) ? body : [body]).map(body => {
-
-  // Exctract properties that conform to the internal model, but keep custom props
-  const { id, type, purpose, value, created, creator, ...rest } = body;
-
-  // The internal model strictly requires IDs. (Because multi-user scenarios
-  // will have problems without them.) In the W3C model, bodys *may* have IDs.
-  // We'll create ad-hoc IDs for bodies without IDs, but want to make sure that
-  // generating the ID is idempotent: the same body should always get the same ID.
-  // This will avoid unexpected results when checking for equality.  
-  return {
-    id: id || `temp-${hashCode(body)}`,
-    annotation: annotationId,
-    type,
-    purpose,
-    value,
-    created,
-    creator: creator ? 
-      typeof creator === 'object' ? { ...creator }: creator :
-      undefined,
-    ...rest
-  }
-
-});
-
-/** Serialization helper to remove core-specific fields from the annotation body **/
-export const serializeW3CBodies = (bodies: AnnotationBody[]): W3CAnnotationBody[] => 
-  bodies.map(b => {
-    const w3c = { ...b };
-    delete w3c.annotation;
-
-    if (w3c.id?.startsWith('temp-'))
-      delete w3c.id;
-  
-    return w3c;
-  });

package/src/presence/Appearance.ts

@@ -1,9 +0,0 @@
-export interface Appearance {
-
-  label: string;
-
-  color: string;
-
-  avatar?: string;
-
-}

package/src/presence/AppearanceProvider.ts

@@ -1,53 +0,0 @@
-import type { User } from '../model';
-import type { Appearance } from './Appearance';
-import type { PresentUser } from './PresentUser';
-import { DEFAULT_PALETTE } from './ColorPalette';
-
-export interface AppearanceProvider {
-
-  addUser(presenceKey: string, user: User): Appearance;
-
-  removeUser(user: PresentUser): void;
-
-}
-
-export const defaultColorProvider = () => {
-
-  const unassignedColors = [...DEFAULT_PALETTE];
-
-  const assignRandomColor = () => {
-    const rnd = Math.floor(Math.random() * unassignedColors.length);
-    const color = unassignedColors[rnd];
-
-    unassignedColors.splice(rnd, 1);
-
-    return color;
-  }
-
-  const releaseColor = (color: string) =>
-    unassignedColors.push(color);
-
-  return { assignRandomColor, releaseColor };
-
-}
-
-export const createDefaultAppearenceProvider = () => {
-
-  const colorProvider = defaultColorProvider();
-
-  const addUser = (presenceKey: string, user: User): Appearance => {
-    const color = colorProvider.assignRandomColor();
-
-    return {
-      label: user.name || user.id,
-      avatar: user.avatar,
-      color
-    };
-  }
-
-  const removeUser = (user: PresentUser) =>
-    colorProvider.releaseColor(user.appearance.color);
-
-  return { addUser, removeUser }
-  
-}

package/src/presence/ColorPalette.ts

@@ -1,14 +0,0 @@
-// SEABORN_BRIGHT
-export const DEFAULT_PALETTE: Palette = [
-  '#ff7c00', // orange
-  '#1ac938', // green
-  '#e8000b', // red
-  '#8b2be2', // purple
-  '#9f4800', // brown
-  '#f14cc1', // pink
-  '#ffc400', // khaki
-  '#00d7ff', // cyan
-  '#023eff'  // blue
-];
-
-export type Palette = string[];

package/src/presence/PresenceEvents.ts

@@ -1,9 +0,0 @@
-import type { PresentUser } from './PresentUser';
-
-export interface PresenceEvents {
-
-  presence: (users: PresentUser[]) => void;
-
-  selectionChange: (from: PresentUser, selection: string[] | null) => void;
-
-}

package/src/presence/PresenceProvider.ts

@@ -1,7 +0,0 @@
-import type { PresenceEvents } from './PresenceEvents';
-
-export interface PresenceProvider {
-
-  on<E extends keyof PresenceEvents>(event: E, callback: PresenceEvents[E]): void;
-
-}

package/src/presence/PresenceState.ts

@@ -1,145 +0,0 @@
-import { nanoid } from 'nanoid';
-import { createNanoEvents, type Unsubscribe } from 'nanoevents';
-import type { User } from '../model';
-import type { PresentUser } from './PresentUser';
-import type { PresenceEvents } from './PresenceEvents';
-import { createDefaultAppearenceProvider } from './AppearanceProvider';
-import type { AppearanceProvider } from './AppearanceProvider';
-
-export interface PresenceState {
-
-  // Get users currently present to this room
-  getPresentUsers(): PresentUser[];
-
-  // Notify of a given present user's activity on the given annotations
-  notifyActivity(presenceKey: string, annotationIds: string[]): void;
-
-  // Add a listener for the given presence event
-  on<E extends keyof PresenceEvents>(event: E, callback: PresenceEvents[E]): Unsubscribe;
-
-  // Initial sync - which users are present under which keys
-  syncUsers(state: { presenceKey: string, user: User }[]): void;
-
-  // Update the selection state for the given prresent user
-  updateSelection(presenceKey: string, selection: string[] | null): void;
-
-}
-
-const isListEqual = (listA: any[], listB: any[]) => 
-  listA.every(a => listA.includes(a)) && listB.every(b => listA.includes(b));
-
-// This client's presence key
-export const PRESENCE_KEY = nanoid();
-
-export const createPresenceState = (
-  appearanceProvider: AppearanceProvider = createDefaultAppearenceProvider()
-): PresenceState => {
-
-  const emitter = createNanoEvents<PresenceEvents>();
-
-  const presentUsers = new Map<string, PresentUser>();
-
-  const selectionStates = new Map<string, string[]>();
-
-  const addUser = (presenceKey: string, user: User) => {
-    if (presentUsers.has(presenceKey)) {
-      console.warn('Attempt to add user that is already present', presenceKey, user);
-      return;    
-    }
-
-    const appearance = appearanceProvider.addUser(presenceKey, user);
-
-    presentUsers.set(presenceKey, { 
-      ...user,
-      presenceKey,
-      appearance
-    });
-  }
-
-  const removeUser = (presenceKey: string) => {
-    const user = presentUsers.get(presenceKey);
-    if (!user) {
-      console.warn('Attempt to remove user that is not present', presenceKey);
-      return;
-    }
-
-    appearanceProvider.removeUser(user);
-
-    presentUsers.delete(presenceKey);
-  }
-
-  const syncUsers = (state: { presenceKey: string, user: User }[]) => {
-    // const keys = new Set(others.map(s => s.presenceKey));
-    const keys = new Set(state.map(s => s.presenceKey));
-
-    // These users need to be added to the presentUsers list
-    // const toAdd = others.filter(({ presenceKey }) => !presentUsers.has(presenceKey));
-    const toAdd = state.filter(({ presenceKey }) => !presentUsers.has(presenceKey));
-
-    // These users need to be dropped from the list
-    const toRemove = Array.from(presentUsers.values()).filter(presentUser =>
-      !keys.has(presentUser.presenceKey));
-
-    toAdd.forEach(({ presenceKey, user }) => addUser(presenceKey, user));
-
-    toRemove.forEach(user => {
-      const { presenceKey } = user;
-
-      // If this user has a selection, fire deselect event
-      if (selectionStates.has(presenceKey))
-        emitter.emit('selectionChange', user, null);
-
-      removeUser(presenceKey)
-    });
-
-    if (toAdd.length > 0 || toRemove.length > 0)
-      emitter.emit('presence', getPresentUsers());
-  }
-
-  const notifyActivity = (presenceKey: string, annotationIds: string[]) => {    
-    const user = presentUsers.get(presenceKey);
-    
-    if (!user) {
-      console.warn('Activity notification from user that is not present');
-      return;
-    }
-
-    const currentSelection = selectionStates.get(presenceKey);
-
-    // Was there a selection change we might have missed?
-    if (!currentSelection || !isListEqual(currentSelection, annotationIds)) {
-      selectionStates.set(presenceKey, annotationIds);
-      emitter.emit('selectionChange', user, annotationIds);
-    }
-  }
-
-  const updateSelection = (presenceKey: string, selection: string[] | null) => {
-    const from = presentUsers.get(presenceKey);
-    if (!from) {
-      console.warn('Selection change for user that is not present', presenceKey);
-      return;
-    }
-
-    if (selection)
-      selectionStates.set(presenceKey, selection);
-    else 
-      selectionStates.delete(presenceKey);
-
-    emitter.emit('selectionChange', from, selection);
-  }
-
-  const getPresentUsers = () =>
-    [...Array.from(presentUsers.values())];
-    
-  const on = <E extends keyof PresenceEvents>(event: E, callback: PresenceEvents[E]) =>
-    emitter.on(event, callback);
-
-  return {
-    getPresentUsers,
-    notifyActivity,
-    on,
-    syncUsers,
-    updateSelection
-  }
-
-}

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