@nulib/clover 0.0.0-stage → 4.0.0-beta.0

package/dist/core/annotations.mjs

@@ -0,0 +1,73 @@
+"use client";
+import { GROUPS } from "./painting.mjs";
+import { bodiesOf } from "./painting.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function readFragment(id, fragment) {
+  const time = /(?:^|[#&])t=([^&]+)/.exec(fragment);
+  const t = time && { t: time[1] };
+  const xywh = /(?:^|[#&])xywh=(?:pixel:)?([^&]+)/.exec(fragment);
+  if (xywh) {
+    const [x, y, w, h] = xywh[1].split(",").map(Number);
+    if ([x, y, w, h].every(Number.isFinite)) {
+      return { id, rect: { x, y, w, h }, ...t };
+    }
+  }
+  return t && { id, ...t };
+}
+function readUri(uri) {
+  const hash = uri.indexOf("#");
+  if (hash >= 0) {
+    const id = uri.slice(0, hash);
+    return readFragment(id, uri.slice(hash)) ?? { id };
+  }
+  const query = uri.indexOf("&t=");
+  if (query >= 0) return { id: uri.slice(0, query), t: uri.slice(query + 3) };
+  return { id: uri };
+}
+const first = (target) => {
+  var _a;
+  return Array.isArray(target) ? first(target[0]) : GROUPS.includes(target == null ? void 0 : target.type) ? first((_a = target.items) == null ? void 0 : _a[0]) : target;
+};
+function parseAnnotationTarget(target) {
+  return readTarget(first(target));
+}
+function readTarget(target) {
+  var _a;
+  if (typeof target === "string") return readUri(target);
+  if (!target || typeof target !== "object") return { id: "" };
+  if (target.type !== "SpecificResource" || target.source === void 0) {
+    return readUri(target.id ?? "");
+  }
+  const source = typeof target.source === "string" ? readUri(target.source) : readUri(((_a = target.source) == null ? void 0 : _a.id) ?? "");
+  for (const raw of asArray(target.selector)) {
+    const selector = raw;
+    if ((selector == null ? void 0 : selector.type) === "PointSelector") {
+      return {
+        id: source.id,
+        point: { x: Number(selector.x), y: Number(selector.y) }
+      };
+    }
+    if ((selector == null ? void 0 : selector.type) === "SvgSelector" && selector.value) {
+      return { id: source.id, svg: String(selector.value) };
+    }
+    if ((selector == null ? void 0 : selector.type) === "FragmentSelector" && selector.value) {
+      const parsed = readFragment(source.id, String(selector.value));
+      if (parsed) return parsed;
+    }
+  }
+  return source;
+}
+const isSound = (type) => type === "Audio" || type === "Sound";
+const supplementsOnly = (motivation) => {
+  const motivations = asArray(motivation);
+  return motivations.length > 0 && motivations.every((each) => each === "supplementing");
+};
+const isRegionText = (motivation, target) => supplementsOnly(motivation) && Boolean(target.rect || target.svg || target.point) && !target.t;
+export {
+  GROUPS,
+  bodiesOf,
+  isRegionText,
+  isSound,
+  parseAnnotationTarget,
+  supplementsOnly
+};

package/dist/core/clover.mjs

@@ -0,0 +1,393 @@
+"use client";
+import { findEntry, selectDrawnSets, selectHiddenSets, manifestOfAnnotation, readPage } from "./annotation-sets.mjs";
+import { buildContentState } from "./content-state.mjs";
+import { fetchResource, loadContent, loadManifest } from "./load.mjs";
+import { referencedPages, fetchPage, embedPage } from "./pages.mjs";
+import { selectVisibleCanvases, selectCanvas, selectSequence, canvasOfView, selectPosition, selectStart } from "./selectors.mjs";
+import { searchServiceOf, SEARCH_SET_ID } from "./search-service.mjs";
+import { createStore, createChannel } from "./store.mjs";
+function navigationOf(clover, position, total) {
+  return {
+    position,
+    total,
+    hasPrevious: position > 0,
+    hasNext: position + 1 < total,
+    previous: () => clover.previous(),
+    next: () => clover.next(),
+    first: () => clover.first(),
+    last: () => clover.last(),
+    goTo: (canvasId) => clover.goTo(canvasId)
+  };
+}
+const NO_SEARCH = {
+  query: "",
+  status: "idle",
+  hits: [],
+  set: null
+};
+const INITIAL = {
+  status: "idle",
+  error: null,
+  manifest: null,
+  collection: null,
+  canvasId: null,
+  target: null,
+  annotationId: null,
+  hiddenSets: [],
+  shownSets: [],
+  addedSets: [],
+  search: NO_SEARCH
+};
+function createClover(options = {}) {
+  const store = createStore(INITIAL);
+  const viewport = createChannel(null);
+  const media = createChannel(null);
+  const captions = createChannel(null);
+  const highlight = createChannel(null);
+  const chapter = createChannel(null);
+  let annotating = null;
+  let searching = null;
+  let hostSets = [];
+  let stateSets = [];
+  let pending = null;
+  const added = () => hostSets.length || stateSets.length ? [...hostSets, ...stateSets] : INITIAL.addedSets;
+  let request = options.request;
+  let loading = null;
+  const requested = /* @__PURE__ */ new Set();
+  let pageScope = "view";
+  let allHeld = 0;
+  const embedVisiblePages = () => {
+    const { manifest, canvasId } = store.get();
+    if (!manifest) return;
+    const signal = loading == null ? void 0 : loading.signal;
+    for (const [canvas, list, pageId] of referencedPages(
+      pageScope === "all" || allHeld > 0 ? selectSequence(manifest).canvases : selectVisibleCanvases(manifest, canvasId)
+    )) {
+      if (requested.has(pageId)) continue;
+      requested.add(pageId);
+      fetchPage(pageId, canvas, request, signal).then((page) => {
+        if (signal == null ? void 0 : signal.aborted) return;
+        store.set(
+          (state) => state.manifest ? { manifest: embedPage(state.manifest, canvas, list, page) } : {}
+        );
+      }).catch(() => requested.delete(pageId));
+    }
+  };
+  store.subscribe(embedVisiblePages);
+  const arrive = (manifest, collection, deepLink, initial, pick) => {
+    var _a, _b, _c;
+    const { canvases } = selectSequence(manifest);
+    const has = (id) => Boolean(id) && canvases.some((canvas) => canvas.id === id);
+    const start = selectStart(manifest);
+    const target = has(deepLink == null ? void 0 : deepLink.canvasId) ? deepLink : has(start == null ? void 0 : start.canvasId) ? start : null;
+    const canvasId = has(initial.canvasId) ? initial.canvasId : (target == null ? void 0 : target.canvasId) ?? (has(initial.defaultCanvasId) ? initial.defaultCanvasId : null) ?? ((_a = canvases[0]) == null ? void 0 : _a.id) ?? null;
+    searching == null ? void 0 : searching.abort();
+    const picked = pick && ((_b = findEntry(stateSets, pick)) == null ? void 0 : _b.canvasId) === canvasId ? pick : null;
+    const arrival = target && picked ? { ...target, region: void 0 } : target;
+    store.set({
+      status: "ready",
+      search: NO_SEARCH,
+      manifest,
+      collection,
+      canvasId,
+      target: arrival && arrival.canvasId === canvasId ? arrival : null,
+      addedSets: added(),
+      annotationId: picked
+    });
+    if (canvasId && canvasId !== initial.canvasId) {
+      (_c = options.onCanvasChange) == null ? void 0 : _c.call(options, canvasId);
+    }
+  };
+  const setVisible = (setId, visible) => store.set((state) => {
+    const hidden = state.hiddenSets.filter((id) => id !== setId);
+    const shown = state.shownSets.filter((id) => id !== setId);
+    return visible ? { hiddenSets: hidden, shownSets: [...shown, setId] } : { hiddenSets: [...hidden, setId], shownSets: shown };
+  });
+  const navigate = (canvasId, target) => {
+    var _a, _b, _c;
+    if (!canvasId) return;
+    if ((_a = options.isControlled) == null ? void 0 : _a.call(options)) {
+      if (target) store.set({ target });
+      (_b = options.onCanvasChange) == null ? void 0 : _b.call(options, canvasId);
+      return;
+    }
+    const changed = store.get().canvasId !== canvasId;
+    store.set({ canvasId, target });
+    if (changed) (_c = options.onCanvasChange) == null ? void 0 : _c.call(options, canvasId);
+  };
+  const stepTo = (view, autoplay = false) => {
+    const { manifest } = store.get();
+    const canvasId = canvasOfView(manifest, view);
+    navigate(canvasId, canvasId && autoplay ? { canvasId, autoplay } : null);
+  };
+  const position = () => {
+    const { manifest, canvasId } = store.get();
+    return {
+      at: selectPosition(manifest, canvasId),
+      total: selectSequence(manifest).views.length
+    };
+  };
+  const begin = () => {
+    loading == null ? void 0 : loading.abort();
+    const controller = new AbortController();
+    loading = controller;
+    requested.clear();
+    store.set({ status: "loading", error: null, annotationId: null });
+    return controller.signal;
+  };
+  const fail = (error) => store.set({
+    status: "error",
+    error: error instanceof Error ? error : new Error(String(error))
+  });
+  async function load(content, initial = {}) {
+    var _a;
+    const signal = begin();
+    try {
+      const loaded = await loadContent(content, {
+        request,
+        signal,
+        manifestId: initial.manifestId ?? void 0
+      });
+      if (signal.aborted) return;
+      const note = loaded.annotation;
+      const noted = note ? readPage({ items: [note] }, `${note.id}#content-state`) : [];
+      stateSets = noted.length ? [{ id: `${note.id}#content-state`, source: "added", entries: noted }] : loaded.annotationSets ?? [];
+      const pick = pending ?? ((_a = noted[0]) == null ? void 0 : _a.id) ?? loaded.pick;
+      pending = null;
+      arrive(
+        loaded.manifest,
+        loaded.collection ?? null,
+        loaded.target,
+        initial,
+        pick
+      );
+    } catch (error) {
+      if (!signal.aborted) fail(error);
+    }
+  }
+  const isShown = (id) => {
+    const { manifest, collection } = store.get();
+    return (manifest == null ? void 0 : manifest.id) === id || (collection == null ? void 0 : collection.id) === id;
+  };
+  const memberOf = (id) => {
+    var _a;
+    return (((_a = store.get().collection) == null ? void 0 : _a.items) ?? []).find(
+      (item) => item.id === id
+    ) ?? { id, type: "Manifest" };
+  };
+  const openAnnotation = (manifestId, id) => {
+    var _a, _b;
+    pending = id;
+    if ((_a = options.isManifestControlled) == null ? void 0 : _a.call(options)) {
+      (_b = options.onManifestChange) == null ? void 0 : _b.call(options, manifestId);
+      return;
+    }
+    void show({ id: manifestId, type: "Manifest" }).then(
+      (shown) => {
+        var _a2;
+        return shown && ((_a2 = options.onManifestChange) == null ? void 0 : _a2.call(options, manifestId));
+      }
+    );
+  };
+  const show = async (member, canvasId) => {
+    if (member.type === "Collection") {
+      await load(member.id);
+      return store.get().status === "ready";
+    }
+    const { collection } = store.get();
+    const signal = begin();
+    const pick = pending;
+    pending = null;
+    const waiting = pick ? findEntry(stateSets, pick) : null;
+    try {
+      const next = await loadManifest(member, { request, signal });
+      if (signal.aborted) return false;
+      arrive(
+        next,
+        collection,
+        waiting ? { canvasId: waiting.canvasId } : canvasId ? { canvasId } : void 0,
+        {},
+        pick
+      );
+      return true;
+    } catch (error) {
+      if (!signal.aborted) fail(error);
+      return false;
+    }
+  };
+  return {
+    store,
+    viewport,
+    media,
+    captions,
+    highlight,
+    chapter,
+    get request() {
+      return request;
+    },
+    setRequest(next) {
+      request = next;
+    },
+    load,
+    async openCollection(id) {
+      var _a;
+      const shown = store.get().manifest;
+      if (!shown || ((_a = store.get().collection) == null ? void 0 : _a.id) === id) return;
+      try {
+        const collection = await fetchResource(id, { request });
+        if (collection.type !== "Collection") return;
+        if (store.get().manifest !== shown) return;
+        store.set({ collection });
+      } catch {
+      }
+    },
+    async goToManifest(id, canvasId) {
+      var _a, _b, _c;
+      if (isShown(id)) return;
+      const member = memberOf(id);
+      if (member.type !== "Collection" && ((_a = options.isManifestControlled) == null ? void 0 : _a.call(options))) {
+        (_b = options.onManifestChange) == null ? void 0 : _b.call(options, id);
+        return;
+      }
+      if (await show(member, canvasId)) {
+        (_c = options.onManifestChange) == null ? void 0 : _c.call(options, store.get().manifest.id);
+      }
+    },
+    async syncManifest(id) {
+      if (!id || isShown(id) || store.get().status !== "ready") return;
+      await show(memberOf(id));
+    },
+    goTo(canvasId, target) {
+      navigate(canvasId, target ? { ...target, canvasId } : null);
+    },
+    next({ autoplay = false, wrap = false } = {}) {
+      const { at, total } = position();
+      if (at + 1 < total) stepTo(at + 1, autoplay);
+      else if (wrap && total > 1) stepTo(0, autoplay);
+    },
+    previous() {
+      const { at } = position();
+      if (at > 0) stepTo(at - 1);
+    },
+    first() {
+      stepTo(0);
+    },
+    last() {
+      stepTo(position().total - 1);
+    },
+    consumeTarget() {
+      store.set({ target: null });
+    },
+    syncCanvas(canvasId) {
+      if (canvasId) store.set({ canvasId });
+    },
+    selectAnnotation(id) {
+      const { manifest, addedSets, canvasId, search } = store.get();
+      const entry = findEntry(
+        selectDrawnSets(manifest, addedSets, search.set),
+        id
+      );
+      store.set({ annotationId: entry ? id : null });
+      if (!entry) return;
+      const { hiddenSets, shownSets } = store.get();
+      if (entry.setId !== SEARCH_SET_ID && selectHiddenSets(manifest, addedSets, hiddenSets, shownSets).includes(
+        entry.setId
+      ))
+        setVisible(entry.setId, true);
+      const shown = selectVisibleCanvases(manifest, canvasId).some(
+        (canvas) => canvas.id === entry.canvasId
+      );
+      const exists = selectCanvas(manifest, entry.canvasId) !== null;
+      if (!shown && exists) navigate(entry.canvasId, null);
+      const elsewhere = exists ? void 0 : manifestOfAnnotation(entry.annotation);
+      if (elsewhere) openAnnotation(elsewhere, entry.id);
+    },
+    async search(query) {
+      searching == null ? void 0 : searching.abort();
+      const service = searchServiceOf(store.get().manifest);
+      const q = query.trim();
+      if (!q || !service) {
+        searching = null;
+        store.set({ search: NO_SEARCH, annotationId: null });
+        return;
+      }
+      const controller = new AbortController();
+      searching = controller;
+      store.set((state) => ({
+        search: { ...state.search, query: q, status: "loading" }
+      }));
+      try {
+        const { searchInto } = await import("./search.mjs");
+        await searchInto(store, service, q, request, controller.signal);
+      } catch {
+        store.set({
+          search: { query: q, status: "error", hits: [], set: null }
+        });
+      }
+    },
+    setSetVisible(setId, visible) {
+      setVisible(setId, visible);
+    },
+    async loadAnnotations(input) {
+      annotating == null ? void 0 : annotating.abort();
+      if (!input) {
+        hostSets = [];
+        store.set({ addedSets: added() });
+        return;
+      }
+      const controller = new AbortController();
+      annotating = controller;
+      try {
+        const { loadAnnotationSets } = await import("./annotation-collection.mjs");
+        const sets = await loadAnnotationSets(input, {
+          request,
+          signal: controller.signal
+        });
+        if (controller.signal.aborted) return;
+        hostSets = sets;
+        store.set({ addedSets: added() });
+      } catch {
+      }
+    },
+    getContentState() {
+      const { manifest, canvasId } = store.get();
+      if (!manifest || !canvasId) return null;
+      const view = viewport.get();
+      const element = media.get();
+      const time = element && element.currentTime > 0 ? element.currentTime : null;
+      const current = view && selectVisibleCanvases(manifest, canvasId).some(
+        (canvas) => canvas.id === view.canvasId
+      );
+      const onView = current && !time ? view : null;
+      return buildContentState({
+        manifestId: manifest.id,
+        canvasId: (onView == null ? void 0 : onView.canvasId) ?? canvasId,
+        region: onView == null ? void 0 : onView.region,
+        time
+      });
+    },
+    setAnnotationPages(scope) {
+      if (scope === pageScope) return;
+      pageScope = scope;
+      embedVisiblePages();
+    },
+    holdAllAnnotationPages() {
+      allHeld++;
+      embedVisiblePages();
+      let held = true;
+      return () => {
+        if (held) allHeld--;
+        held = false;
+      };
+    },
+    dispose() {
+      loading == null ? void 0 : loading.abort();
+      annotating == null ? void 0 : annotating.abort();
+      searching == null ? void 0 : searching.abort();
+    }
+  };
+}
+export {
+  createClover,
+  navigationOf
+};

package/dist/core/content-state-reader.mjs

@@ -0,0 +1,82 @@
+"use client";
+import { parseAnnotationTarget } from "./annotations.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function decodeBase64Url(encoded) {
+  const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  try {
+    return decodeURIComponent(binary);
+  } catch {
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+  }
+}
+function decodeContentState(value) {
+  const trimmed = value.trim();
+  for (const read of [
+    () => JSON.parse(trimmed),
+    () => JSON.parse(decodeBase64Url(trimmed))
+  ]) {
+    try {
+      const json = read();
+      if (json && typeof json === "object") return json;
+    } catch {
+    }
+  }
+  return null;
+}
+function startTime(t) {
+  if (!t) return void 0;
+  const seconds = Number(t.split(",")[0]);
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+const collectionOf = (resource) => asArray(resource == null ? void 0 : resource.partOf).find(
+  (part) => (part == null ? void 0 : part.id) && part.type === "Collection"
+);
+function resolveContentState(json) {
+  const target = json.type === "Annotation" ? asArray(json.target)[0] : json;
+  if (!target) return null;
+  const parsed = parseAnnotationTarget(target);
+  const resource = typeof target === "string" ? { id: parsed.id } : target.type === "SpecificResource" ? typeof target.source === "string" ? { id: target.source } : target.source ?? {} : target;
+  const type = resource.type;
+  if (type === "Manifest" || type === "Collection") {
+    const collection2 = type === "Manifest" ? collectionOf(resource) : void 0;
+    return collection2 ? { id: collection2.id, type: "Collection", manifestId: parsed.id } : { id: parsed.id, type };
+  }
+  const pointTime = asArray(target.selector).find(
+    (selector) => (selector == null ? void 0 : selector.type) === "PointSelector" && selector.t != null
+  );
+  const canvasTarget = { canvasId: parsed.id };
+  if (parsed.rect) canvasTarget.region = parsed.rect;
+  const time = (pointTime == null ? void 0 : pointTime.t) ?? startTime(parsed.t);
+  if (time !== void 0) canvasTarget.time = Number(time);
+  const partOf = asArray(resource.partOf).find(
+    (part) => (part == null ? void 0 : part.id) && (!part.type || part.type === "Manifest")
+  );
+  const collection = collectionOf(partOf);
+  const annotation = json.type === "Annotation" && asArray(json.body).length ? {
+    id: json.id ?? `${parsed.id}#content-state`,
+    type: "Annotation",
+    motivation: asArray(json.motivation),
+    body: json.body,
+    target
+  } : void 0;
+  const shared = annotation ? { annotation } : {};
+  return collection && partOf ? {
+    id: collection.id,
+    type: "Collection",
+    manifestId: partOf.id,
+    target: canvasTarget,
+    ...shared
+  } : partOf ? { id: partOf.id, type: "Manifest", target: canvasTarget, ...shared } : {
+    id: parsed.id,
+    type: type ?? "Canvas",
+    target: canvasTarget,
+    ...shared
+  };
+}
+export {
+  decodeContentState,
+  resolveContentState
+};

package/dist/core/content-state.mjs

@@ -0,0 +1,43 @@
+"use client";
+import { asArray } from "../lib/asArray.mjs";
+function isContentState(json) {
+  const value = json;
+  if (!value || typeof value !== "object") return false;
+  if (value.type === "Annotation") {
+    return asArray(value.motivation).includes("contentState");
+  }
+  return value.type === "SpecificResource";
+}
+function encodeContentState(json) {
+  return btoa(encodeURIComponent(JSON.stringify(json))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function buildContentState({
+  manifestId,
+  canvasId,
+  region,
+  time
+}) {
+  const source = {
+    id: canvasId,
+    type: "Canvas",
+    partOf: [{ id: manifestId, type: "Manifest" }]
+  };
+  const fragment = time != null && time > 0 ? `t=${Math.round(time * 100) / 100}` : region ? `xywh=${[region.x, region.y, region.w, region.h].map(Math.round).join(",")}` : null;
+  const json = {
+    "@context": "http://iiif.io/api/presentation/3/context.json",
+    id: `${canvasId}#content-state`,
+    type: "Annotation",
+    motivation: ["contentState"],
+    target: fragment ? {
+      type: "SpecificResource",
+      source,
+      selector: { type: "FragmentSelector", value: fragment }
+    } : source
+  };
+  return { json, encoded: encodeContentState(json) };
+}
+export {
+  buildContentState,
+  encodeContentState,
+  isContentState
+};

package/dist/core/direction.mjs

@@ -0,0 +1,12 @@
+"use client";
+const RTL_LANGUAGE = /^(ar|arc|ckb|dv|fa|he|iw|ks|ps|sd|syr|ug|ur|yi)$/;
+const RTL_SCRIPT = /^(adlm|arab|hebr|nkoo|rohg|syrc|thaa)$/;
+function directionOf(lang) {
+  if (!lang) return void 0;
+  const [primary, ...subtags] = lang.toLowerCase().split(/[-_]/);
+  const script = subtags.find((subtag) => subtag.length === 4);
+  return (script ? RTL_SCRIPT.test(script) : RTL_LANGUAGE.test(primary)) ? "rtl" : void 0;
+}
+export {
+  directionOf
+};

package/dist/core/geo-detect.mjs

@@ -0,0 +1,30 @@
+"use client";
+import { selectSequence } from "./selectors.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function hasMapData(manifest, collection = null) {
+  if (!manifest) return false;
+  if ((collection == null ? void 0 : collection.navPlace) || manifest.navPlace) {
+    return true;
+  }
+  for (const canvas of selectSequence(manifest).canvases) {
+    if (canvas.navPlace) return true;
+    for (const page of asArray(canvas.annotations)) {
+      for (const annotation of asArray(page == null ? void 0 : page.items)) {
+        if (annotation == null ? void 0 : annotation.navPlace) return true;
+        if (asArray(annotation == null ? void 0 : annotation.motivation).includes("georeferencing")) {
+          return true;
+        }
+        const bodies = asArray(annotation == null ? void 0 : annotation.body);
+        if (bodies.some(
+          (body) => (body == null ? void 0 : body.type) === "Feature" || (body == null ? void 0 : body.type) === "FeatureCollection"
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+export {
+  hasMapData
+};