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

package/dist/core/markdown.mjs

@@ -0,0 +1,139 @@
+"use client";
+const BULLET = /^\s*[-*+]\s+/;
+const NUMBER = /^\s*(\d+)[.)]\s+/;
+const HEADING = /^(#{1,6})\s+(\S.*?)(?:\s+#+)?\s*$/;
+const GROUPS = Symbol.for("clover.markdown.groups");
+const nextGroup = () => {
+  const page = globalThis;
+  return page[GROUPS] = (page[GROUPS] ?? 0) + 1;
+};
+const escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function inline(text, notes) {
+  const links = [];
+  const marked = escape(text).replace(
+    /\[([^\]]+)\]\((https?:\/\/[^\s)]+|mailto:[^\s)]+)\)/g,
+    (_, label, url) => {
+      links.push(url);
+      return `\0${links.length - 1}
${label}`;
+    }
+  ).replace(/\[\^([^\]]+)\]/g, (match, key) => {
+    const number = notes.get(key);
+    return number ? `<sup>${number}</sup>` : match;
+  }).replace(/\*\*([^*]+)\*\*|__([^_]+)__/g, (_, a, b) => `<b>${a ?? b}</b>`).replace(
+    /\*([^*\s][^*]*)\*|_([^_\s][^_]*)_/g,
+    (_, a, b) => `<i>${a ?? b}</i>`
+  ).replace(/( {2,}|\\)\n/g, "<br>").replace(/\n/g, " ");
+  return marked.replace(
+    /\u0000(\d+)\u0001([^\u0002]*)\u0002/g,
+    (_, index, label) => `<a href="${links[Number(index)]}">${label}</a>`
+  );
+}
+function blocksOf(body) {
+  const blocks = [];
+  for (const chunk of body.split(/\n(?:[ \t]*\n)+/)) {
+    let last;
+    for (const line of chunk.split("\n")) {
+      if (!line.trim()) continue;
+      const heading = HEADING.exec(line);
+      const number = NUMBER.exec(line);
+      const item = BULLET.test(line) || number && ((last == null ? void 0 : last.kind) !== "paragraph" || Number(number[1]) === 1);
+      if (heading) {
+        last = { kind: "heading", depth: heading[1].length, text: heading[2] };
+        blocks.push(last);
+      } else if (item && (last == null ? void 0 : last.kind) !== "list") {
+        last = { kind: "list", lines: [line] };
+        blocks.push(last);
+      } else if (last && last.kind !== "heading") {
+        last.lines.push(line);
+      } else {
+        last = { kind: "paragraph", lines: [line] };
+        blocks.push(last);
+      }
+    }
+  }
+  return blocks;
+}
+function list(lines, notes) {
+  const items = [];
+  for (const line of lines) {
+    const bullet = BULLET.exec(line);
+    const number = bullet ? null : NUMBER.exec(line);
+    const marker = bullet ?? number;
+    if (marker) {
+      items.push({
+        indent: line.replace(/\t/g, "    ").search(/\S/),
+        tag: bullet ? "ul" : "ol",
+        start: number ? Number(number[1]) : 1,
+        text: line.slice(marker[0].length)
+      });
+    } else items[items.length - 1].text += `
+${line.trimStart()}`;
+  }
+  let html = "";
+  const open = [];
+  const close = () => html += `</li></${open.pop().tag}>`;
+  for (const item of items) {
+    while (open.length > 1 && item.indent <= open[open.length - 2].indent)
+      close();
+    const top = open[open.length - 1];
+    const sibling = top && item.indent <= top.indent;
+    if (sibling && item.tag === top.tag) html += "</li><li>";
+    else {
+      if (sibling) close();
+      const start = item.tag === "ol" && item.start !== 1 ? ` start="${item.start}"` : "";
+      html += `<${item.tag}${start}><li>`;
+      open.push({ indent: sibling ? top.indent : item.indent, tag: item.tag });
+    }
+    html += inline(item.text.trim(), notes);
+  }
+  while (open.length) close();
+  return html;
+}
+function markdownToHtml(markdown, { headingLevel = 3 } = {}) {
+  const notes = /* @__PURE__ */ new Map();
+  const definitions = [];
+  const body = markdown.replace(/\r\n?/g, "\n").replace(/^\[\^([^\]]+)\]:\s*(.*)$/gm, (_, key, text) => {
+    notes.set(key, notes.size + 1);
+    definitions.push([key, text]);
+    return "";
+  });
+  const base = Math.max(headingLevel, 1);
+  const above = [];
+  const open = [];
+  const html = [];
+  for (const block of blocksOf(body)) {
+    if (block.kind === "heading") {
+      while (above.length && above[above.length - 1] >= block.depth)
+        above.pop();
+      while (open.length && open[open.length - 1] >= block.depth) {
+        open.pop();
+        html.push("</div>");
+      }
+      const level = base + above.length;
+      above.push(block.depth);
+      const text = `<b>${inline(block.text, notes)}</b>`;
+      if (level <= 6) {
+        html.push(`<p role="heading" aria-level="${level}">${text}</p>`);
+      } else {
+        const id = `clover-md-${nextGroup()}`;
+        open.push(block.depth);
+        html.push(
+          `<div role="group" aria-labelledby="${id}"><p id="${id}">${text}</p>`
+        );
+      }
+    } else if (block.kind === "list") html.push(list(block.lines, notes));
+    else html.push(`<p>${inline(block.lines.join("\n").trim(), notes)}</p>`);
+  }
+  while (open.pop() !== void 0) html.push("</div>");
+  if (definitions.length) {
+    html.push(
+      `<p><small>${definitions.map(
+        ([key, text]) => `<sup>${notes.get(key)}</sup> ${inline(text, notes)}`
+      ).join("<br>")}</small></p>`
+    );
+  }
+  return html.join("");
+}
+export {
+  markdownToHtml
+};

package/dist/core/pages.mjs

@@ -0,0 +1,51 @@
+"use client";
+import { isPresentation4, toPresentation4 } from "./presentation.mjs";
+import { fetchJson } from "./request.mjs";
+const isReference = (page) => Boolean(page == null ? void 0 : page.id) && page.type === "AnnotationPage" && !page.items;
+function referencedPages(canvases) {
+  const found = [];
+  for (const canvas of canvases) {
+    for (const list of ["items", "annotations"]) {
+      for (const page of canvas[list] ?? []) {
+        if (isReference(page)) found.push([canvas.id, list, page.id]);
+      }
+    }
+  }
+  return found;
+}
+async function fetchPage(id, canvasId, request, signal) {
+  return upgradePage(await fetchJson(request, id, signal), canvasId);
+}
+async function upgradePage(json, canvasId = "urn:clover:annotation-page") {
+  var _a;
+  const page = json;
+  if (isPresentation4(page)) return page;
+  const canvas = await toPresentation4({
+    "@context": page["@context"] ?? "http://iiif.io/api/presentation/3/context.json",
+    id: canvasId,
+    type: "Canvas",
+    items: [{ ...page, "@context": void 0 }]
+  });
+  return ((_a = canvas.items) == null ? void 0 : _a[0]) ?? page;
+}
+function embedPage(manifest, canvasId, list, page) {
+  let changed = false;
+  const items = (manifest.items ?? []).map(
+    (canvas) => {
+      if (canvas.id !== canvasId || !Array.isArray(canvas[list])) return canvas;
+      const pages = canvas[list].map((existing) => {
+        if (existing.id !== page.id || !isReference(existing)) return existing;
+        changed = true;
+        return page;
+      });
+      return changed ? { ...canvas, [list]: pages } : canvas;
+    }
+  );
+  return changed ? { ...manifest, items } : manifest;
+}
+export {
+  embedPage,
+  fetchPage,
+  referencedPages,
+  upgradePage
+};

package/dist/core/painted-bodies.mjs

@@ -0,0 +1,20 @@
+"use client";
+import { isPainting, bodiesOf } from "./painting.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function paintedBodies(container) {
+  const painted = [];
+  for (const page of asArray(container == null ? void 0 : container.items))
+    for (const annotation of asArray(page == null ? void 0 : page.items)) {
+      if (!isPainting(annotation)) continue;
+      for (let body of bodiesOf(annotation)) {
+        if ((body == null ? void 0 : body.type) === "Choice") body = asArray(body.items)[0];
+        if ((body == null ? void 0 : body.type) === "SpecificResource")
+          body = typeof body.source === "string" ? { id: body.source } : body.source;
+        if (body) painted.push({ body, annotation });
+      }
+    }
+  return painted;
+}
+export {
+  paintedBodies
+};

package/dist/core/painting.mjs

@@ -0,0 +1,17 @@
+"use client";
+import { asArray } from "../lib/asArray.mjs";
+const GROUPS = ["Independents", "Composite", "List"];
+function bodiesOf(annotation) {
+  return asArray(annotation == null ? void 0 : annotation.body).flatMap(
+    (body) => GROUPS.includes(body == null ? void 0 : body.type) ? asArray(body.items) : [body]
+  );
+}
+function isPainting(annotation) {
+  const motivations = asArray(annotation == null ? void 0 : annotation.motivation);
+  return !motivations.length || motivations.includes("painting");
+}
+export {
+  GROUPS,
+  bodiesOf,
+  isPainting
+};

package/dist/core/presentation.mjs

@@ -0,0 +1,27 @@
+"use client";
+const PRESENTATION_4 = /iiif\.io\/api\/presentation\/4\/context\.json/;
+function isPresentation4(resource) {
+  const context = resource == null ? void 0 : resource["@context"];
+  const contexts = Array.isArray(context) ? context : [context];
+  return contexts.some(
+    (value) => typeof value === "string" && PRESENTATION_4.test(value)
+  );
+}
+let upgrader = null;
+function preloadUpgrader() {
+  upgrader ?? (upgrader = import("@iiif/parser/presentation-4/upgrader"));
+  return upgrader;
+}
+async function toPresentation4(resource) {
+  if (isPresentation4(resource)) return resource;
+  const [{ upgradeToPresentation4 }, { keepFragments }] = await Promise.all([
+    preloadUpgrader(),
+    import("./keep-fragments.mjs")
+  ]);
+  return upgradeToPresentation4(keepFragments(resource));
+}
+export {
+  isPresentation4,
+  preloadUpgrader,
+  toPresentation4
+};

package/dist/core/ranges.mjs

@@ -0,0 +1,133 @@
+"use client";
+import { parseAnnotationTarget } from "./annotations.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function parseTime(t) {
+  if (!t) return void 0;
+  const [rawStart, rawEnd] = t.split(",");
+  const start = Number(rawStart);
+  if (rawStart === "" || Number.isNaN(start)) return void 0;
+  if (rawEnd === void 0 || rawEnd === "") return { start };
+  const end = Number(rawEnd);
+  return Number.isNaN(end) ? { start } : { start, end };
+}
+function rangeItemTarget(item) {
+  if (typeof item === "string") return restoreFragment(item);
+  const json = item;
+  if ((json == null ? void 0 : json.type) === "SpecificResource") return json;
+  return typeof (json == null ? void 0 : json.id) === "string" ? restoreFragment(json.id) : json;
+}
+const restoreFragment = (id) => id.replace(/\/((?:t|xywh)=[^/#]*)$/, "#$1");
+const memo = /* @__PURE__ */ new WeakMap();
+const NONE = [];
+function chaptersOf(manifest, canvasId, duration) {
+  if (!manifest || !canvasId) return NONE;
+  let byCanvas = memo.get(manifest);
+  if (!byCanvas) memo.set(manifest, byCanvas = /* @__PURE__ */ new Map());
+  const key = `${canvasId}|${duration ?? ""}`;
+  const cached = byCanvas.get(key);
+  if (cached) return cached;
+  const found = [];
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (range) => {
+    if (!range || visited.has(range.id ?? range)) return;
+    visited.add(range.id ?? range);
+    for (const item of asArray(range.items)) {
+      if ((item == null ? void 0 : item.type) === "Range") {
+        walk(item);
+        continue;
+      }
+      const parsed = parseAnnotationTarget(rangeItemTarget(item));
+      if (parsed.id.split("#")[0] !== canvasId) continue;
+      const time = parseTime(parsed.t);
+      if (time)
+        found.push({
+          ...range.id ? { id: range.id } : {},
+          label: range.label,
+          ...time
+        });
+    }
+  };
+  for (const structure of asArray(manifest.structures)) {
+    walk(structure);
+  }
+  found.sort((a, b) => a.start - b.start);
+  const chapters = found.length ? found.map((chapter, index) => {
+    var _a;
+    return {
+      ...chapter,
+      end: chapter.end ?? ((_a = found[index + 1]) == null ? void 0 : _a.start) ?? duration
+    };
+  }) : NONE;
+  byCanvas.set(key, chapters);
+  return chapters;
+}
+const tocs = /* @__PURE__ */ new WeakMap();
+const NO_TOC = [];
+function tableOfContents(manifest) {
+  if (!manifest) return NO_TOC;
+  const cached = tocs.get(manifest);
+  if (cached) return cached;
+  const visited = /* @__PURE__ */ new Set();
+  const build = (range) => {
+    var _a, _b;
+    if (!range || visited.has(range.id ?? range)) return [];
+    visited.add(range.id ?? range);
+    const children = [];
+    const canvasIds = [];
+    let first;
+    for (const item of asArray(range.items)) {
+      if ((item == null ? void 0 : item.type) === "Range") {
+        const built = build(item);
+        children.push(...built);
+        built.forEach((child) => canvasIds.push(...child.canvasIds));
+      } else {
+        const parsed = parseAnnotationTarget(rangeItemTarget(item));
+        if (!parsed.id) continue;
+        first ?? (first = parsed);
+        canvasIds.push(parsed.id);
+      }
+    }
+    const behavior = asArray(range.behavior);
+    if (behavior.includes("no-nav")) return children;
+    const start = first ?? void 0;
+    const node = {
+      id: range.id ?? `range-${visited.size}`,
+      label: range.label,
+      canvasId: (start == null ? void 0 : start.id) ?? ((_a = children[0]) == null ? void 0 : _a.canvasId),
+      canvasIds: [...new Set(canvasIds)],
+      children
+    };
+    const time = parseTime(start == null ? void 0 : start.t);
+    if (time) node.time = time;
+    else if (!start && ((_b = children[0]) == null ? void 0 : _b.time)) node.time = children[0].time;
+    if (start == null ? void 0 : start.rect) node.region = start.rect;
+    return [node];
+  };
+  const roots = asArray(manifest.structures).flatMap(
+    build
+  );
+  const nodes = roots.length === 1 && roots[0].children.length ? roots[0].children : roots;
+  const result = nodes.length ? nodes : NO_TOC;
+  tocs.set(manifest, result);
+  return result;
+}
+function currentContents(nodes, canvasId, time) {
+  let best = null;
+  const walk = (node, depth) => {
+    if (canvasId && node.canvasIds.includes(canvasId)) {
+      const within = !node.time || time !== void 0 && time >= node.time.start && (node.time.end === void 0 || time < node.time.end);
+      if (within && (!best || depth >= best.depth))
+        best = { id: node.id, depth };
+    }
+    node.children.forEach((child) => walk(child, depth + 1));
+  };
+  nodes.forEach((node) => walk(node, 0));
+  return best ? best.id : null;
+}
+export {
+  chaptersOf,
+  currentContents,
+  parseTime,
+  rangeItemTarget,
+  tableOfContents
+};

package/dist/core/region.mjs

@@ -0,0 +1,32 @@
+"use client";
+import { parseAnnotationTarget } from "./annotations.mjs";
+import { findImageServiceId } from "../lib/renderer/sources/imageService.mjs";
+import { isPainting } from "./painting.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function regionSource(canvas, rect) {
+  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;
+      for (const body of asArray(annotation == null ? void 0 : annotation.body)) {
+        if ((body == null ? void 0 : body.type) !== "Image" || !body.width || !body.height) continue;
+        const service = findImageServiceId(body.service);
+        if (!service) continue;
+        const target = parseAnnotationTarget(
+          asArray(annotation.target)[0]
+        ).rect ?? { x: 0, y: 0, w: canvas.width, h: canvas.height };
+        const left = (rect.x - target.x) / target.w;
+        const top = (rect.y - target.y) / target.h;
+        const x = Math.max(0, left);
+        const y = Math.max(0, top);
+        const width = Math.min(1, left + rect.w / target.w) - x;
+        const height = Math.min(1, top + rect.h / target.h) - y;
+        if (!(width > 0 && height > 0)) continue;
+        return { service, region: { x, y, width, height } };
+      }
+    }
+  }
+  return null;
+}
+export {
+  regionSource
+};

package/dist/core/request.mjs

@@ -0,0 +1,40 @@
+"use client";
+function cloverFetch(request, url, init = {}) {
+  const run = (request == null ? void 0 : request.fetch) ?? globalThis.fetch;
+  return run(url, {
+    credentials: (request == null ? void 0 : request.credentials) ?? "same-origin",
+    ...init,
+    headers: { ...init.headers, ...request == null ? void 0 : request.headers }
+  });
+}
+const sendsCredentials = (request) => (request == null ? void 0 : request.credentials) === "include";
+const requestKey = (request) => JSON.stringify([request == null ? void 0 : request.credentials, request == null ? void 0 : request.headers]);
+class CloverRequestError extends Error {
+  constructor(message, url, status) {
+    super(message);
+    this.url = url;
+    this.status = status;
+    this.name = "CloverRequestError";
+  }
+}
+async function fetchJson(request, url, signal) {
+  const response = await cloverFetch(request, url, {
+    signal,
+    headers: { Accept: "application/ld+json, application/json" }
+  });
+  if (!response.ok) {
+    throw new CloverRequestError(
+      `${url} answered ${response.status}`,
+      url,
+      response.status
+    );
+  }
+  return response.json();
+}
+export {
+  CloverRequestError,
+  cloverFetch,
+  fetchJson,
+  requestKey,
+  sendsCredentials
+};

package/dist/core/sanitize.mjs

@@ -0,0 +1,72 @@
+"use client";
+import DOMPurify from "dompurify";
+const TAGS = ["a", "b", "br", "i", "img", "p", "small", "span", "sub", "sup"];
+const ATTRIBUTES = ["href", "alt", "src", "height", "width", "lang", "dir"];
+const URI_SAFE = ["height", "width", "lang", "dir"];
+const URI = /^(?:https?|mailto):/i;
+const CONFIG = {
+  ALLOWED_TAGS: TAGS,
+  ALLOWED_ATTR: ATTRIBUTES,
+  ADD_URI_SAFE_ATTR: URI_SAFE,
+  ALLOWED_URI_REGEXP: URI,
+  // Only the attributes listed: DOMPurify otherwise keeps every `aria-*` and `data-*`.
+  ALLOW_ARIA_ATTR: false,
+  ALLOW_DATA_ATTR: false
+};
+const MARKDOWN_CONFIG = {
+  ...CONFIG,
+  ALLOWED_TAGS: [...TAGS, "ul", "ol", "li", "div"],
+  ALLOWED_ATTR: [
+    ...ATTRIBUTES,
+    "role",
+    "aria-level",
+    "start",
+    "id",
+    "aria-labelledby"
+  ],
+  ADD_URI_SAFE_ATTR: [
+    ...URI_SAFE,
+    "aria-level",
+    "start",
+    "id",
+    "aria-labelledby"
+  ]
+};
+const GROUP_ID = /^clover-md-\d+$/;
+const MARKDOWN_VALUES = {
+  role: [
+    ["P", /^heading$/],
+    ["DIV", /^group$/]
+  ],
+  "aria-level": [["P", /^[1-6]$/]],
+  start: [["OL", /^\d+$/]],
+  id: [["P", GROUP_ID]],
+  "aria-labelledby": [["DIV", GROUP_ID]]
+};
+let purify = null;
+function purifier() {
+  if (purify) return purify;
+  purify = DOMPurify(window);
+  purify.addHook("afterSanitizeAttributes", (node) => {
+    var _a, _b;
+    for (const name of ["src", "href"]) {
+      const value = (_a = node.getAttribute) == null ? void 0 : _a.call(node, name);
+      if (value && !URI.test(value.trim())) node.removeAttribute(name);
+    }
+    for (const [name, allowed] of Object.entries(MARKDOWN_VALUES)) {
+      const value = (_b = node.getAttribute) == null ? void 0 : _b.call(node, name);
+      if (value != null && !allowed.some(
+        ([tag, pattern]) => node.nodeName === tag && pattern.test(value)
+      ))
+        node.removeAttribute(name);
+    }
+  });
+  return purify;
+}
+function sanitizeHTML(html, { markdown = false } = {}) {
+  if (typeof window === "undefined") return html;
+  return purifier().sanitize(html, markdown ? MARKDOWN_CONFIG : CONFIG);
+}
+export {
+  sanitizeHTML
+};

package/dist/core/search-service.mjs

@@ -0,0 +1,22 @@
+"use client";
+import { asArray } from "../lib/asArray.mjs";
+const SEARCH_SET_ID = "content-search";
+const VERSION = /\/search\/([0-2])\//;
+function searchServiceOf(manifest) {
+  if (!manifest) return null;
+  let found = null;
+  for (const service of asArray(manifest.service)) {
+    const id = (service == null ? void 0 : service.id) ?? (service == null ? void 0 : service["@id"]);
+    if (typeof id !== "string") continue;
+    const type = String(service.type ?? service["@type"] ?? "");
+    const hint = [service.profile, service["@context"]].flat().map((value) => String(value ?? "")).join(" ");
+    const version = type === "SearchService2" ? 2 : type === "SearchService1" ? 1 : VERSION.test(hint) ? Number(VERSION.exec(hint)[1]) >= 2 ? 2 : 1 : null;
+    if (version === 2) return { id, version };
+    if (version === 1) found ?? (found = { id, version });
+  }
+  return found;
+}
+export {
+  SEARCH_SET_ID,
+  searchServiceOf
+};