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

package/dist/core/geo.mjs

@@ -0,0 +1,283 @@
+"use client";
+import { parseAnnotationTarget } from "./annotations.mjs";
+import { bodiesOf, isPainting } from "./painting.mjs";
+import { selectSequence } from "./selectors.mjs";
+import { toPlainText } from "./text.mjs";
+import { localize } from "./value.mjs";
+import { asArray } from "../lib/asArray.mjs";
+const GEOMETRIES = /* @__PURE__ */ new Set([
+  "Point",
+  "MultiPoint",
+  "LineString",
+  "MultiLineString",
+  "Polygon",
+  "MultiPolygon",
+  "GeometryCollection"
+]);
+const STYLE_KEYS = [
+  "fill",
+  "fill-opacity",
+  "stroke",
+  "stroke-width",
+  "stroke-opacity",
+  "marker-color"
+];
+function featuresOf(geo) {
+  const value = geo;
+  if (!value || typeof value !== "object") return [];
+  if (value.type === "FeatureCollection") {
+    return asArray(value.features).filter(
+      (feature) => feature == null ? void 0 : feature.geometry
+    );
+  }
+  if (value.type === "Feature") return value.geometry ? [value] : [];
+  if (GEOMETRIES.has(value.type)) return [{ type: "Feature", geometry: value }];
+  return [];
+}
+function flatten(feature, owner, language) {
+  const own = feature.properties ?? {};
+  const properties = {};
+  for (const key of STYLE_KEYS) {
+    const value = own[key];
+    if (typeof value === "string" || typeof value === "number") {
+      properties[key] = value;
+    }
+  }
+  const ownTitle = localize(own.label, language);
+  const title = ownTitle.text ? ownTitle : localize(owner.label, language);
+  if (title.text) {
+    properties.title = toPlainText(title.text);
+    if (title.lang) properties.titleLang = title.lang;
+  }
+  if (owner.canvasId) properties.canvasId = owner.canvasId;
+  return {
+    type: "Feature",
+    ...feature.id != null ? { id: feature.id } : {},
+    geometry: feature.geometry,
+    properties
+  };
+}
+const GEOREFERENCING = "georeferencing";
+const motivations = (annotation) => asArray(annotation == null ? void 0 : annotation.motivation);
+function annotationsOf(canvas) {
+  return asArray(canvas.annotations).flatMap(
+    (page) => asArray(page == null ? void 0 : page.items)
+  );
+}
+const navPlaces = /* @__PURE__ */ new WeakMap();
+function navPlaceOf(manifest, collection = null, language) {
+  if (!manifest) return NO_FEATURES;
+  const key = `${language ?? ""}|${(collection == null ? void 0 : collection.id) ?? ""}`;
+  let byKey = navPlaces.get(manifest);
+  if (!byKey) navPlaces.set(manifest, byKey = /* @__PURE__ */ new Map());
+  const cached = byKey.get(key);
+  if (cached) return cached;
+  const features = [];
+  const add = (geo, owner) => features.push(...featuresOf(geo).map((f) => flatten(f, owner, language)));
+  const c = collection;
+  if (c == null ? void 0 : c.navPlace) add(c.navPlace, { label: c.label });
+  const m = manifest;
+  if (m.navPlace) add(m.navPlace, { label: m.label });
+  for (const canvas of selectSequence(manifest).canvases) {
+    if (canvas.navPlace) {
+      add(canvas.navPlace, { label: canvas.label, canvasId: canvas.id });
+    }
+    for (const annotation of annotationsOf(canvas)) {
+      if (motivations(annotation).includes(GEOREFERENCING)) continue;
+      const canvasId = parseAnnotationTarget(asArray(annotation.target)[0]).id || canvas.id;
+      const owner = { label: annotation.label ?? canvas.label, canvasId };
+      if (annotation.navPlace) add(annotation.navPlace, owner);
+      for (const body of bodiesOf(annotation)) {
+        if ((body == null ? void 0 : body.type) === "Feature" || (body == null ? void 0 : body.type) === "FeatureCollection") {
+          add(body, owner);
+        }
+      }
+    }
+  }
+  const result = features.length ? { type: "FeatureCollection", features } : NO_FEATURES;
+  byKey.set(key, result);
+  return result;
+}
+const NO_FEATURES = {
+  type: "FeatureCollection",
+  features: []
+};
+const NO_GEOREFERENCES = [];
+function readMask(svg) {
+  var _a;
+  if (typeof svg !== "string") return void 0;
+  const points = (_a = /points\s*=\s*["']([^"']+)["']/i.exec(svg)) == null ? void 0 : _a[1];
+  if (!points) return void 0;
+  const numbers = points.trim().split(/[\s,]+/).map(Number);
+  const mask = [];
+  for (let i = 0; i + 1 < numbers.length; i += 2) {
+    mask.push([numbers[i], numbers[i + 1]]);
+  }
+  return mask.length >= 3 && mask.every((p) => p.every(Number.isFinite)) ? mask : void 0;
+}
+function paintedImage(canvas) {
+  for (const page of asArray(canvas == null ? void 0 : canvas.items)) {
+    for (const annotation of asArray(page == null ? void 0 : page.items)) {
+      if (!isPainting(annotation)) continue;
+      const body = bodiesOf(annotation).find(
+        (item) => (item == null ? void 0 : item.type) === "Image" || (item == null ? void 0 : item.service)
+      );
+      if (body) return body;
+    }
+  }
+  return void 0;
+}
+function readGeoreference(annotation, canvas) {
+  var _a, _b;
+  if (!motivations(annotation).includes(GEOREFERENCING)) return null;
+  const body = bodiesOf(annotation).find(
+    (item) => (item == null ? void 0 : item.type) === "FeatureCollection"
+  );
+  const points = [];
+  for (const feature of featuresOf(body)) {
+    const resource = (_a = feature.properties) == null ? void 0 : _a.resourceCoords;
+    const geo = ((_b = feature.geometry) == null ? void 0 : _b.type) === "Point" && feature.geometry.coordinates;
+    if (!Array.isArray(resource) || !Array.isArray(geo)) continue;
+    const point = {
+      resource: [Number(resource[0]), Number(resource[1])],
+      geo: [Number(geo[0]), Number(geo[1])]
+    };
+    if ([...point.resource, ...point.geo].every(Number.isFinite)) {
+      points.push(point);
+    }
+  }
+  if (points.length < 3) return null;
+  const target = asArray(annotation.target)[0];
+  const source = typeof target === "string" ? { id: target } : typeof (target == null ? void 0 : target.source) === "string" ? { id: target.source } : (target == null ? void 0 : target.source) ?? target ?? {};
+  const sourceId = String(source.id ?? source["@id"] ?? "").split("#")[0];
+  const sourceType = String(source.type ?? source["@type"] ?? "");
+  const isService = /ImageService/.test(sourceType);
+  const width = Number(source.width ?? (canvas == null ? void 0 : canvas.width));
+  const height = Number(source.height ?? (canvas == null ? void 0 : canvas.height));
+  if (!(width > 0 && height > 0)) return null;
+  const image = isService ? { service: [{ id: sourceId, type: sourceType, profile: source.profile }] } : paintedImage(canvas);
+  if (!image) return null;
+  const selector = asArray(target == null ? void 0 : target.selector).find(
+    (item) => (item == null ? void 0 : item.type) === "SvgSelector"
+  );
+  const mask = readMask(selector == null ? void 0 : selector.value);
+  const whole = (mask == null ? void 0 : mask.length) === 4 && mask.every(
+    ([x, y]) => (x === 0 || x === width) && (y === 0 || y === height)
+  );
+  const label = annotation.label ?? (canvas == null ? void 0 : canvas.label);
+  return {
+    id: String(annotation.id ?? sourceId),
+    ...isService || !sourceId ? {} : { canvasId: (canvas == null ? void 0 : canvas.id) ?? sourceId },
+    points,
+    width,
+    height,
+    ...mask && !whole ? { mask } : {},
+    ...label ? { label } : {},
+    image
+  };
+}
+const georeferences = /* @__PURE__ */ new WeakMap();
+function georeferencesOf(manifest) {
+  if (!manifest) return NO_GEOREFERENCES;
+  const cached = georeferences.get(manifest);
+  if (cached) return cached;
+  const found = [];
+  for (const canvas of selectSequence(manifest).canvases) {
+    for (const annotation of annotationsOf(canvas)) {
+      const georeference = readGeoreference(annotation, canvas);
+      if (georeference) found.push(georeference);
+    }
+  }
+  const result = found.length ? found : NO_GEOREFERENCES;
+  georeferences.set(manifest, result);
+  return result;
+}
+const toMercator = ([lng, lat]) => [
+  lng * Math.PI / 180,
+  Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))
+];
+const fromMercator = ([x, y]) => [
+  x * 180 / Math.PI,
+  (2 * Math.atan(Math.exp(y)) - Math.PI / 2) * 180 / Math.PI
+];
+function solve3(m, b) {
+  const det = (a) => a[0][0] * (a[1][1] * a[2][2] - a[1][2] * a[2][1]) - a[0][1] * (a[1][0] * a[2][2] - a[1][2] * a[2][0]) + a[0][2] * (a[1][0] * a[2][1] - a[1][1] * a[2][0]);
+  const d = det(m);
+  if (Math.abs(d) < 1e-12) return null;
+  return [0, 1, 2].map(
+    (column) => det(m.map((row, i) => row.map((v, j) => j === column ? b[i] : v))) / d
+  );
+}
+function affineTransform(points) {
+  if (points.length < 3) return null;
+  const ata = [
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0]
+  ];
+  const atx = [0, 0, 0];
+  const aty = [0, 0, 0];
+  for (const { resource, geo } of points) {
+    const row = [resource[0], resource[1], 1];
+    const [mx, my] = toMercator(geo);
+    for (let i = 0; i < 3; i++) {
+      for (let j = 0; j < 3; j++) ata[i][j] += row[i] * row[j];
+      atx[i] += row[i] * mx;
+      aty[i] += row[i] * my;
+    }
+  }
+  const fx = solve3(ata, atx);
+  const fy = solve3(ata, aty);
+  if (!fx || !fy) return null;
+  return ([x, y]) => fromMercator([
+    fx[0] * x + fx[1] * y + fx[2],
+    fy[0] * x + fy[1] * y + fy[2]
+  ]);
+}
+function cornersOf(georeference) {
+  const transform = affineTransform(georeference.points);
+  if (!transform) return null;
+  const { width: w, height: h } = georeference;
+  return [
+    transform([0, 0]),
+    transform([w, 0]),
+    transform([w, h]),
+    transform([0, h])
+  ];
+}
+function positionsOf(geometry) {
+  if (!geometry) return [];
+  if (geometry.type === "GeometryCollection") {
+    return (geometry.geometries ?? []).flatMap(positionsOf);
+  }
+  const flat = [];
+  const walk = (value) => {
+    if (!Array.isArray(value)) return;
+    if (typeof value[0] === "number" && typeof value[1] === "number") {
+      flat.push([value[0], value[1]]);
+    } else value.forEach(walk);
+  };
+  walk(geometry.coordinates);
+  return flat;
+}
+function boundsOf(features, overlays = []) {
+  const positions = [
+    ...features.flatMap((feature) => positionsOf(feature.geometry)),
+    ...overlays.flatMap((overlay) => cornersOf(overlay) ?? [])
+  ].filter(([lng, lat]) => Number.isFinite(lng) && Number.isFinite(lat));
+  if (!positions.length) return null;
+  const lngs = positions.map(([lng]) => lng);
+  const lats = positions.map(([, lat]) => lat);
+  return [
+    [Math.min(...lngs), Math.min(...lats)],
+    [Math.max(...lngs), Math.max(...lats)]
+  ];
+}
+export {
+  affineTransform,
+  boundsOf,
+  cornersOf,
+  georeferencesOf,
+  navPlaceOf,
+  readGeoreference
+};

package/dist/core/items.mjs

@@ -0,0 +1,74 @@
+"use client";
+import { selectSequence } from "./selectors.mjs";
+import { localize } from "./value.mjs";
+import { paintedBodies } from "./painted-bodies.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function paintedType(container) {
+  var _a;
+  return (_a = paintedBodies(container).find(({ body }) => body.type)) == null ? void 0 : _a.body.type;
+}
+function part(resource) {
+  const media = paintedType(resource) ?? (resource.type === "Timeline" ? "Sound" : void 0);
+  return {
+    id: resource.id,
+    type: resource.type,
+    label: resource.label,
+    resource,
+    duration: Number(resource.duration) || void 0,
+    media
+  };
+}
+const viewItems = /* @__PURE__ */ new WeakMap();
+function itemsOfManifest(manifest) {
+  if (!manifest) return [];
+  let items = viewItems.get(manifest);
+  if (!items) {
+    const { canvases, views } = selectSequence(manifest);
+    items = views.map((view) => {
+      const parts = view.map((index) => part(canvases[index]));
+      return {
+        id: parts[0].id,
+        parts,
+        // A spread is named by its pages: "Frontispiece – Title page".
+        label: parts.length === 1 ? parts[0].label : {
+          none: [
+            parts.map((p) => localize(p.label).text).filter(Boolean).join(" – ")
+          ]
+        }
+      };
+    });
+    viewItems.set(manifest, items);
+  }
+  return items;
+}
+const memberItems = /* @__PURE__ */ new WeakMap();
+function itemsOfCollection(collection) {
+  if (!collection) return [];
+  let items = memberItems.get(collection);
+  if (!items) {
+    items = asArray(collection.items).filter((member) => member == null ? void 0 : member.id).map((member) => {
+      var _a;
+      return {
+        id: member.id,
+        parts: [part(member)],
+        label: member.label,
+        summary: member.summary,
+        href: ((_a = asArray(member.homepage)[0]) == null ? void 0 : _a.id) ?? member.id
+      };
+    });
+    memberItems.set(collection, items);
+  }
+  return items;
+}
+function itemsOf(resource) {
+  if (!resource) return [];
+  if (Array.isArray(resource)) {
+    return itemsOfCollection({ items: resource });
+  }
+  return resource.type === "Collection" ? itemsOfCollection(resource) : itemsOfManifest(resource);
+}
+export {
+  itemsOf,
+  itemsOfCollection,
+  itemsOfManifest
+};

package/dist/core/keep-fragments.mjs

@@ -0,0 +1,40 @@
+"use client";
+const fragmented = (target) => Boolean(target) && typeof target === "object" && !Array.isArray(target) && typeof target.id === "string" && target.id.includes("#") && target.type !== "SpecificResource";
+function needs(value) {
+  if (Array.isArray(value)) return value.some(needs);
+  if (!value || typeof value !== "object") return false;
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "target") {
+      const targets = Array.isArray(child) ? child : [child];
+      if (targets.some(fragmented)) return true;
+    }
+    if (needs(child)) return true;
+  }
+  return false;
+}
+function asSpecificResource(target) {
+  const { id, ...rest } = target;
+  const [source, fragment] = id.split("#");
+  return {
+    type: "SpecificResource",
+    source: { ...rest, id: source },
+    selector: { type: "FragmentSelector", value: fragment }
+  };
+}
+function rewrite(value) {
+  if (Array.isArray(value)) return value.map(rewrite);
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    out[key] = key === "target" ? Array.isArray(child) ? child.map(
+      (each) => fragmented(each) ? asSpecificResource(each) : rewrite(each)
+    ) : fragmented(child) ? asSpecificResource(child) : rewrite(child) : rewrite(child);
+  }
+  return out;
+}
+function keepFragments(resource) {
+  return needs(resource) ? rewrite(resource) : resource;
+}
+export {
+  keepFragments
+};

package/dist/core/link.mjs

@@ -0,0 +1,28 @@
+"use client";
+import { parseAnnotationTarget } from "./annotations.mjs";
+import { bodiesOf } from "./painting.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function readLink(annotation) {
+  if (!asArray(annotation == null ? void 0 : annotation.motivation).includes("linking")) return void 0;
+  for (const body of bodiesOf(annotation)) {
+    if ((body == null ? void 0 : body.type) === "TextualBody" || typeof (body == null ? void 0 : body.value) === "string")
+      continue;
+    const source = (body == null ? void 0 : body.type) === "SpecificResource" ? body.source : body;
+    const id = typeof source === "string" ? source : source == null ? void 0 : source.id;
+    if (typeof id !== "string" || !id) continue;
+    if ((source == null ? void 0 : source.type) === "Canvas") {
+      const part = asArray(source.partOf).find(
+        (each) => (each == null ? void 0 : each.id) && (!each.type || each.type === "Manifest")
+      );
+      const canvasId = parseAnnotationTarget(id).id;
+      return { id, canvasId, ...part ? { manifestId: part.id } : {} };
+    }
+    if ((source == null ? void 0 : source.type) === "Manifest" || (source == null ? void 0 : source.type) === "Collection")
+      return { id, manifestId: id };
+    if (/^https?:\/\//i.test(id)) return { id };
+  }
+  return void 0;
+}
+export {
+  readLink
+};

package/dist/core/load.mjs

@@ -0,0 +1,176 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isContentState } from "./content-state.mjs";
+import { preloadUpgrader, toPresentation4 } from "./presentation.mjs";
+import { fetchJson } from "./request.mjs";
+const readContentState = () => import("./content-state-reader.mjs");
+const DESCRIPTIVE = [
+  "summary",
+  "metadata",
+  "requiredStatement",
+  "rights",
+  "provider",
+  "homepage",
+  "seeAlso",
+  "rendering",
+  "thumbnail",
+  "navDate",
+  "partOf"
+];
+function loneCanvas(canvas) {
+  const manifest = {
+    "@context": P4_CONTEXT,
+    id: canvas.id,
+    type: "Manifest",
+    label: canvas.label ?? { none: [""] },
+    items: [canvas]
+  };
+  for (const key of DESCRIPTIVE) {
+    if (canvas[key] !== void 0 && key !== "label")
+      manifest[key] = canvas[key];
+  }
+  return manifest;
+}
+const isLoneCanvas = (manifest) => {
+  var _a, _b;
+  return Boolean(manifest) && ((_b = (_a = manifest.items) == null ? void 0 : _a[0]) == null ? void 0 : _b.id) === manifest.id;
+};
+const ANNOTATIONS = /^(oa:)?Annotation(Page|Collection)$/;
+class CloverContentError extends Error {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "CloverContentError");
+  }
+}
+const P4_CONTEXT = "http://iiif.io/api/presentation/4/context.json";
+const isUrl = (value) => /^https?:\/\//i.test(value);
+async function dereference(resource, { request, signal }) {
+  const embedded = Array.isArray(resource.items) && resource.items.length > 0;
+  if (embedded || !resource.id) return resource;
+  return await fetchJson(request, resource.id, signal);
+}
+const MAX_COLLECTION_PAGES = 50;
+async function withMembers(collection, options) {
+  const json = collection;
+  if (Array.isArray(json.items) && json.items.length) return collection;
+  if (!json.first) return collection;
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  let next = json.first;
+  for (let page = 0; next && page < MAX_COLLECTION_PAGES; page++) {
+    const reference = typeof next === "string" ? { id: next } : next;
+    if (seen.has(reference.id ?? reference)) break;
+    seen.add(reference.id ?? reference);
+    const fetched = reference.items ? reference : await fetchJson(options.request, reference.id, options.signal);
+    const upgraded = await toPresentation4({
+      "@context": fetched["@context"] ?? json["@context"],
+      ...fetched,
+      type: "Collection"
+    });
+    items.push(...upgraded.items ?? []);
+    next = fetched.next;
+  }
+  return { ...json, items };
+}
+async function loadManifest(member, options = {}) {
+  return toPresentation4(await dereference(member, options));
+}
+async function firstManifest(collection, options, depth = 0) {
+  for (const item of collection.items ?? []) {
+    if (item.type === "Manifest") {
+      return toPresentation4(await dereference(item, options));
+    }
+    if (item.type === "Collection" && depth < 8) {
+      const nested = await withMembers(
+        await toPresentation4(await dereference(item, options)),
+        options
+      );
+      const found = await firstManifest(nested, options, depth + 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+async function fetchResource(input, { request, signal } = {}) {
+  void preloadUpgrader();
+  const json = typeof input === "string" ? await fetchJson(request, input.trim(), signal) : input;
+  const resource = await toPresentation4(json);
+  return resource.type === "Collection" ? withMembers(resource, { request, signal }) : resource;
+}
+async function loadContent(input, options = {}) {
+  var _a;
+  const { request, signal } = options;
+  void preloadUpgrader();
+  let target;
+  let member;
+  let annotation;
+  let json;
+  const followContentState = async (state) => {
+    const { resolveContentState } = await readContentState();
+    const resolved = resolveContentState(state);
+    if (!resolved) throw new CloverContentError("Unreadable content state");
+    target = resolved.target ?? target;
+    member = resolved.manifestId ?? member;
+    annotation = resolved.annotation ?? annotation;
+    return fetchJson(request, resolved.id, signal);
+  };
+  if (typeof input === "string") {
+    if (isUrl(input.trim())) {
+      json = await fetchJson(request, input.trim(), signal);
+    } else {
+      const { decodeContentState } = await readContentState();
+      const state = decodeContentState(input);
+      if (!state) throw new CloverContentError("Unreadable iiifContent");
+      json = isContentState(state) ? await followContentState(state) : state;
+    }
+  } else {
+    json = input;
+  }
+  if (isContentState(json)) {
+    json = await followContentState(json);
+  }
+  if (ANNOTATIONS.test(String((json == null ? void 0 : json.type) ?? ""))) {
+    const { annotationsContent } = await import("./annotations-content.mjs");
+    return annotationsContent(json, options);
+  }
+  const resource = await toPresentation4(json);
+  (_a = signal == null ? void 0 : signal.throwIfAborted) == null ? void 0 : _a.call(signal);
+  switch (resource.type) {
+    case "Manifest":
+      return { manifest: resource, target, annotation };
+    case "Collection": {
+      const collection = await withMembers(resource, options);
+      const pick = options.manifestId ?? member;
+      const chosen = pick ? (collection.items ?? []).find(
+        (item) => item.id === pick && item.type === "Manifest"
+      ) : void 0;
+      const manifest = chosen ? await loadManifest(chosen, options) : await firstManifest(collection, options);
+      if (!manifest) {
+        throw new CloverContentError("The Collection holds no Manifest");
+      }
+      return { manifest, collection, target, annotation };
+    }
+    case "Canvas":
+    case "Timeline":
+    case "Scene": {
+      const container = resource;
+      target ?? (target = { canvasId: container.id });
+      return { manifest: loneCanvas(container), target, annotation };
+    }
+    default:
+      throw new CloverContentError(
+        `Cannot show a ${String(resource.type ?? "resource without a type")}`
+      );
+  }
+}
+export {
+  CloverContentError,
+  fetchResource,
+  isLoneCanvas,
+  loadContent,
+  loadManifest,
+  loneCanvas,
+  withMembers
+};

package/dist/core/map-config.mjs

@@ -0,0 +1,12 @@
+"use client";
+let workerUrl;
+function setMapWorkerUrl(url) {
+  workerUrl = url;
+}
+function getMapWorkerUrl() {
+  return workerUrl;
+}
+export {
+  getMapWorkerUrl,
+  setMapWorkerUrl
+};