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

package/dist/index.mjs

@@ -0,0 +1,133 @@
+"use client";
+import { Viewer, Viewer as Viewer2 } from "./components/Viewer/Viewer.mjs";
+import { default as default2 } from "./components/Canvas/index.mjs";
+import { Root } from "./components/Root/Root.mjs";
+import { Body } from "./components/Body/Body.mjs";
+import { Label } from "./components/Label/Label.mjs";
+import { Items } from "./components/Items/Items.mjs";
+import { Next, Position, Previous } from "./components/Items/Pager.mjs";
+import { Status } from "./components/Status/Status.mjs";
+import { Homepage, Id, Metadata, PartOf, Rendering, RequiredStatement, Rights, SeeAlso, Summary, Thumbnail, Value } from "./components/Primitives/Primitives.mjs";
+import { Logo, Provider } from "./components/Provider/Provider.mjs";
+import { Panel, Tab } from "./components/Panel/Panel.mjs";
+import { About } from "./components/Panel/About.mjs";
+import { Annotations } from "./components/Annotations/Annotations.mjs";
+import { Transcript } from "./components/Transcript/Transcript.mjs";
+import { Contents } from "./components/Contents/Contents.mjs";
+import { Download } from "./components/Download/Download.mjs";
+import { Split, SplitHandle, SplitPane } from "./components/Split/Split.mjs";
+import { Search } from "./components/Search/Search.mjs";
+import { search } from "./core/search.mjs";
+import { SEARCH_SET_ID, searchServiceOf } from "./core/search-service.mjs";
+import { setMapWorkerUrl } from "./core/map-config.mjs";
+import { Collection } from "./components/Collection/Collection.mjs";
+import { CollectionSelect } from "./components/CollectionSelect/CollectionSelect.mjs";
+import { PanelToggle } from "./components/Panel/PanelToggle.mjs";
+import { Timeline } from "./components/Timeline/Timeline.mjs";
+import { Scene } from "./components/Scene/Scene.mjs";
+import { useActiveCanvas, useAnnotationSets, useLangOf, useLocalized, useManifest, useNavigation, useSequence, useStatus, useT, useVisibleCanvases } from "./react/hooks.mjs";
+import { useProvider } from "./components/Primitives/resource.mjs";
+import { visuallyHidden } from "./ui/visuallyHidden.mjs";
+import { Tip } from "./ui/Tip.mjs";
+import { useOneOpen } from "./ui/useOneOpen.mjs";
+import { useUniqueId } from "./ui/useUniqueId.mjs";
+import { ReadMore } from "./ui/ReadMore.mjs";
+import { titled } from "./ui/heading.mjs";
+import { useClover, useCloverSelector } from "./react/context.mjs";
+import { toPresentation4 } from "./core/presentation.mjs";
+import { buildContentState, encodeContentState } from "./core/content-state.mjs";
+import { decodeContentState } from "./core/content-state-reader.mjs";
+import { cueAt, parseVtt } from "./core/vtt.mjs";
+import { chaptersOf, currentContents, tableOfContents } from "./core/ranges.mjs";
+import { localize } from "./core/value.mjs";
+import { readAs, toPlainText } from "./core/text.mjs";
+import { resolveThumbnail, stillSource, thumbnailSource } from "./core/thumbnail.mjs";
+import { regionSource } from "./core/region.mjs";
+import { groupViews, resolveBehavior, resolveDirection } from "./core/sequence.mjs";
+import { CLOVER_I18N_NAMESPACE, initCloverI18n } from "./i18n/config.mjs";
+export {
+  About,
+  Annotations,
+  Body,
+  CLOVER_I18N_NAMESPACE,
+  default2 as Canvas,
+  Collection,
+  CollectionSelect,
+  Contents,
+  Download,
+  Homepage,
+  Id,
+  Items,
+  Label,
+  Logo,
+  Metadata,
+  Next,
+  Panel,
+  PanelToggle,
+  PartOf,
+  Position,
+  Previous,
+  Provider,
+  ReadMore,
+  Rendering,
+  RequiredStatement,
+  Rights,
+  Root,
+  SEARCH_SET_ID,
+  Scene,
+  Search,
+  SeeAlso,
+  Split,
+  SplitHandle,
+  SplitPane,
+  Status,
+  Summary,
+  Tab,
+  Thumbnail,
+  Timeline,
+  Tip,
+  Transcript,
+  Value,
+  Viewer,
+  buildContentState,
+  chaptersOf,
+  cueAt,
+  currentContents,
+  decodeContentState,
+  Viewer2 as default,
+  encodeContentState,
+  groupViews,
+  initCloverI18n,
+  localize,
+  parseVtt,
+  readAs,
+  regionSource,
+  resolveBehavior,
+  resolveDirection,
+  resolveThumbnail,
+  search,
+  searchServiceOf,
+  setMapWorkerUrl,
+  stillSource,
+  tableOfContents,
+  thumbnailSource,
+  titled,
+  toPlainText,
+  toPresentation4,
+  useActiveCanvas,
+  useAnnotationSets,
+  useClover,
+  useCloverSelector,
+  useLangOf,
+  useLocalized,
+  useManifest,
+  useNavigation,
+  useOneOpen,
+  useProvider,
+  useSequence,
+  useStatus,
+  useT,
+  useUniqueId,
+  useVisibleCanvases,
+  visuallyHidden
+};

package/dist/lib/asArray.mjs

@@ -0,0 +1,5 @@
+"use client";
+const asArray = (value) => Array.isArray(value) ? value : value == null ? [] : [value];
+export {
+  asArray
+};

package/dist/lib/classnames.mjs

@@ -0,0 +1,5 @@
+"use client";
+const join = (...names) => names.filter(Boolean).join(" ");
+export {
+  join
+};

package/dist/lib/fullscreen.mjs

@@ -0,0 +1,65 @@
+"use client";
+const getFullscreenElement = () => {
+  if (typeof document === "undefined") return null;
+  const doc = document;
+  return doc.fullscreenElement ?? doc.webkitFullscreenElement ?? null;
+};
+const isFullscreenSupported = () => {
+  if (typeof document === "undefined") return false;
+  const doc = document;
+  return Boolean(doc.fullscreenEnabled ?? doc.webkitFullscreenEnabled);
+};
+const getCloverRoot = (from) => from == null ? void 0 : from.closest(".clover-canvas");
+const enterNativeFullscreen = (video, from) => {
+  if (typeof video.webkitEnterFullscreen !== "function") return;
+  const canvas = from.closest(".clover-canvas");
+  const placed = !video.isConnected && Boolean(canvas);
+  if (placed && canvas) {
+    const style = video.getAttribute("style");
+    video.style.cssText = "position:absolute;inset:0;z-index:-1;width:100%;height:100%;object-fit:contain;pointer-events:none";
+    canvas.prepend(video);
+    video.addEventListener(
+      "webkitendfullscreen",
+      () => {
+        video.remove();
+        if (style === null) video.removeAttribute("style");
+        else video.setAttribute("style", style);
+      },
+      { once: true }
+    );
+  }
+  const enter = () => {
+    var _a;
+    try {
+      (_a = video.webkitEnterFullscreen) == null ? void 0 : _a.call(video);
+    } catch {
+    }
+  };
+  if (placed) requestAnimationFrame(enter);
+  else enter();
+};
+const toggleFullscreen = async (from, video) => {
+  var _a, _b, _c, _d;
+  const root = getCloverRoot(from);
+  if (!root) return;
+  try {
+    if (getFullscreenElement()) {
+      const doc = document;
+      await (((_a = doc.exitFullscreen) == null ? void 0 : _a.call(doc)) ?? ((_b = doc.webkitExitFullscreen) == null ? void 0 : _b.call(doc)));
+      return;
+    }
+    if (!isFullscreenSupported()) {
+      if (video && from) enterNativeFullscreen(video, from);
+      return;
+    }
+    const element = root;
+    await (((_c = element.requestFullscreen) == null ? void 0 : _c.call(element)) ?? ((_d = element.webkitRequestFullscreen) == null ? void 0 : _d.call(element)));
+  } catch {
+  }
+};
+export {
+  getCloverRoot,
+  getFullscreenElement,
+  isFullscreenSupported,
+  toggleFullscreen
+};

package/dist/lib/gltf/bounds.mjs

@@ -0,0 +1,44 @@
+"use client";
+import { readAccessor } from "./load.mjs";
+const emptyBox = () => ({
+  min: [Infinity, Infinity, Infinity],
+  max: [-Infinity, -Infinity, -Infinity]
+});
+function turnsNothing(model) {
+  for (let column = 0; column < 3; column++) {
+    let axes = 0;
+    for (let row = 0; row < 3; row++)
+      if (Math.abs(model[column * 4 + row]) > 1e-6) axes++;
+    if (axes > 1) return false;
+  }
+  return true;
+}
+function growBox(box, asset, position, model) {
+  const accessor = asset.json.accessors[position];
+  let points;
+  if (turnsNothing(model) && accessor.min && accessor.max && !accessor.normalized) {
+    const [min, max] = [accessor.min, accessor.max];
+    points = Array.from({ length: 8 }, (_, corner) => [
+      corner & 1 ? max[0] : min[0],
+      corner & 2 ? max[1] : min[1],
+      corner & 4 ? max[2] : min[2]
+    ]).flat();
+  } else points = readAccessor(asset, position);
+  const m = model;
+  for (let i = 0; i + 2 < points.length; i += 3) {
+    const x = points[i];
+    const y = points[i + 1];
+    const z = points[i + 2];
+    for (let axis = 0; axis < 3; axis++) {
+      const value = m[axis] * x + m[4 + axis] * y + m[8 + axis] * z + m[12 + axis];
+      if (value < box.min[axis]) box.min[axis] = value;
+      if (value > box.max[axis]) box.max[axis] = value;
+    }
+  }
+  return box;
+}
+export {
+  emptyBox,
+  growBox,
+  turnsNothing
+};

package/dist/lib/gltf/load.mjs

@@ -0,0 +1,156 @@
+"use client";
+import { requestKey, cloverFetch } from "../../core/request.mjs";
+const EXTENSIONS = [
+  "KHR_materials_unlit",
+  "KHR_materials_ior",
+  "KHR_materials_specular",
+  "KHR_mesh_quantization"
+];
+const GLB = 1179937895;
+const JSON_CHUNK = 1313821514;
+const BIN_CHUNK = 5130562;
+function parseGlb(data) {
+  const view = new DataView(data);
+  if (view.getUint32(0, true) !== GLB) throw new Error("This is not a GLB.");
+  if (view.getUint32(4, true) !== 2) throw new Error("Only glTF 2.0 is drawn.");
+  let json;
+  let bin;
+  const length = Math.min(view.getUint32(8, true), data.byteLength);
+  for (let offset = 12; offset + 8 <= length; ) {
+    const size = view.getUint32(offset, true);
+    const type = view.getUint32(offset + 4, true);
+    const start = offset + 8;
+    if (type === JSON_CHUNK)
+      json = JSON.parse(
+        new TextDecoder().decode(new Uint8Array(data, start, size))
+      );
+    else if (type === BIN_CHUNK) bin = data.slice(start, start + size);
+    offset = start + size;
+  }
+  if (!json) throw new Error("The GLB has no JSON chunk.");
+  return { json, bin };
+}
+async function fetchBytes(uri, base, request) {
+  const url = new URL(uri, base).href;
+  const response = url.startsWith("data:") ? await fetch(url) : await cloverFetch(request, url);
+  if (!response.ok) throw new Error(`${url} answered ${response.status}`);
+  return response.arrayBuffer();
+}
+const loading = /* @__PURE__ */ new WeakMap();
+function loadGltf(url, request) {
+  const run = (request == null ? void 0 : request.fetch) ?? globalThis.fetch;
+  const loads = loading.get(run) ?? /* @__PURE__ */ new Map();
+  loading.set(run, loads);
+  const key = `${requestKey(request)} ${url}`;
+  let load = loads.get(key);
+  if (!load) {
+    load = readGltf(url, request).finally(() => loads.delete(key));
+    loads.set(key, load);
+  }
+  return load;
+}
+async function readGltf(url, request) {
+  const data = await fetchBytes(url, location.href, request);
+  const glb = new DataView(data).getUint32(0, true) === GLB;
+  const { json, bin } = glb ? parseGlb(data) : { json: JSON.parse(new TextDecoder().decode(data)) };
+  const missing = (json.extensionsRequired ?? []).filter(
+    (name) => !EXTENSIONS.includes(name)
+  );
+  if (missing.length)
+    throw new Error(
+      `Clover's renderer cannot draw this model: it requires ${missing.join(", ")}.`
+    );
+  const buffers = await Promise.all(
+    (json.buffers ?? []).map((buffer, index) => {
+      if (buffer.uri !== void 0) return fetchBytes(buffer.uri, url, request);
+      if (index === 0 && bin) return bin;
+      throw new Error("A buffer of the model has no data.");
+    })
+  );
+  const images = await Promise.all(
+    (json.images ?? []).map(async (image) => {
+      try {
+        let blob;
+        if (image.bufferView !== void 0) {
+          const view = json.bufferViews[image.bufferView];
+          blob = new Blob(
+            [
+              new Uint8Array(
+                buffers[view.buffer],
+                view.byteOffset ?? 0,
+                view.byteLength
+              )
+            ],
+            { type: image.mimeType }
+          );
+        } else if (image.uri !== void 0) {
+          blob = new Blob([await fetchBytes(image.uri, url, request)], {
+            type: image.mimeType
+          });
+        } else return null;
+        return await createImageBitmap(blob, {
+          premultiplyAlpha: "none",
+          colorSpaceConversion: "none"
+        });
+      } catch {
+        return null;
+      }
+    })
+  );
+  return { json, buffers, images };
+}
+const COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+const COMPONENT_BYTES = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+const componentsOf = (type) => COMPONENTS[type];
+function readAccessor(asset, index) {
+  const accessor = asset.json.accessors[index];
+  const size = componentsOf(accessor.type);
+  const out = new Float32Array(accessor.count * size);
+  if (accessor.bufferView === void 0) return out;
+  const view = asset.json.bufferViews[accessor.bufferView];
+  const bytes = COMPONENT_BYTES[accessor.componentType];
+  const stride = view.byteStride || bytes * size;
+  const data = new DataView(
+    asset.buffers[view.buffer],
+    (view.byteOffset ?? 0) + (accessor.byteOffset ?? 0)
+  );
+  const read = {
+    5120: (o) => data.getInt8(o),
+    5121: (o) => data.getUint8(o),
+    5122: (o) => data.getInt16(o, true),
+    5123: (o) => data.getUint16(o, true),
+    5125: (o) => data.getUint32(o, true),
+    5126: (o) => data.getFloat32(o, true)
+  }[accessor.componentType] ?? (() => 0);
+  const scale = accessor.normalized ? { 5120: 127, 5121: 255, 5122: 32767, 5123: 65535 }[accessor.componentType] : void 0;
+  for (let element = 0; element < accessor.count; element++) {
+    for (let component = 0; component < size; component++) {
+      const value = read(element * stride + component * bytes);
+      out[element * size + component] = scale ? Math.max(value / scale, -1) : value;
+    }
+  }
+  return out;
+}
+export {
+  COMPONENT_BYTES,
+  EXTENSIONS,
+  componentsOf,
+  loadGltf,
+  parseGlb,
+  readAccessor
+};

package/dist/lib/gltf/mat4.mjs

@@ -0,0 +1,150 @@
+"use client";
+const identity = () => new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+function multiply(a, b) {
+  const out = new Float32Array(16);
+  for (let column = 0; column < 4; column++) {
+    for (let row = 0; row < 4; row++) {
+      let sum = 0;
+      for (let k = 0; k < 4; k++) sum += a[k * 4 + row] * b[column * 4 + k];
+      out[column * 4 + row] = sum;
+    }
+  }
+  return out;
+}
+function compose([tx, ty, tz], [x, y, z, w], [sx, sy, sz]) {
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const xy = x * y2;
+  const xz = x * z2;
+  const yy = y * y2;
+  const yz = y * z2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  return new Float32Array([
+    (1 - (yy + zz)) * sx,
+    (xy + wz) * sx,
+    (xz - wy) * sx,
+    0,
+    (xy - wz) * sy,
+    (1 - (xx + zz)) * sy,
+    (yz + wx) * sy,
+    0,
+    (xz + wy) * sz,
+    (yz - wx) * sz,
+    (1 - (xx + yy)) * sz,
+    0,
+    tx,
+    ty,
+    tz,
+    1
+  ]);
+}
+const translation = (move) => compose(move, [0, 0, 0, 1], [1, 1, 1]);
+const scaling = (scale) => compose([0, 0, 0], [0, 0, 0, 1], scale);
+function rotation([x, y, z]) {
+  const about = (axis, degrees) => {
+    const angle = degrees * Math.PI / 180;
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    const m = identity();
+    const [i, j] = axis === 0 ? [1, 2] : axis === 1 ? [2, 0] : [0, 1];
+    m[i * 4 + i] = c;
+    m[i * 4 + j] = s;
+    m[j * 4 + i] = -s;
+    m[j * 4 + j] = c;
+    return m;
+  };
+  return multiply(about(2, z), multiply(about(1, y), about(0, x)));
+}
+function perspective(fieldOfView, aspect, near, far) {
+  const f = 1 / Math.tan(fieldOfView / 2);
+  const range = 1 / (near - far);
+  return new Float32Array([
+    f / aspect,
+    0,
+    0,
+    0,
+    0,
+    f,
+    0,
+    0,
+    0,
+    0,
+    (far + near) * range,
+    -1,
+    0,
+    0,
+    2 * far * near * range,
+    0
+  ]);
+}
+function lookAt(eye, target) {
+  const unit = (v) => {
+    const length = Math.hypot(...v) || 1;
+    return [v[0] / length, v[1] / length, v[2] / length];
+  };
+  const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  const back = unit([
+    eye[0] - target[0],
+    eye[1] - target[1],
+    eye[2] - target[2]
+  ]);
+  const right = unit(cross([0, 1, 0], back));
+  const up = cross(back, right);
+  return new Float32Array([
+    right[0],
+    up[0],
+    back[0],
+    0,
+    right[1],
+    up[1],
+    back[1],
+    0,
+    right[2],
+    up[2],
+    back[2],
+    0,
+    -dot(right, eye),
+    -dot(up, eye),
+    -dot(back, eye),
+    1
+  ]);
+}
+function normalMatrix(m) {
+  const [a, b, c, , d, e, f, , g, h, i] = m;
+  const A = e * i - f * h;
+  const B = f * g - d * i;
+  const C = d * h - e * g;
+  const det = a * A + b * B + c * C || 1;
+  return new Float32Array([
+    A / det,
+    B / det,
+    C / det,
+    (c * h - b * i) / det,
+    (a * i - c * g) / det,
+    (b * g - a * h) / det,
+    (b * f - c * e) / det,
+    (c * d - a * f) / det,
+    (a * e - b * d) / det
+  ]);
+}
+export {
+  compose,
+  identity,
+  lookAt,
+  multiply,
+  normalMatrix,
+  perspective,
+  rotation,
+  scaling,
+  translation
+};