@nulib/clover 4.0.0-beta.1 → 4.0.0

package/dist/core/annotation-sets.mjs

@@ -3,7 +3,9 @@ import { isRegionText, parseAnnotationTarget } from "./annotations.mjs";
 import { readBodies } from "./annotation-bodies.mjs";
 import { asArray } from "../lib/asArray.mjs";
 import { SEARCH_SET_ID } from "./search-service.mjs";
-import { selectCanvas, selectSequence } from "./selectors.mjs";
+import { selectSequence, selectCanvas } from "./selectors.mjs";
+const CONTENTS_SET_ID = "contents";
+const regionEntryId = (rangeId, index) => `${rangeId}#region-${index + 1}`;
 const isLinking = (annotation) => asArray(annotation == null ? void 0 : annotation.motivation).includes("linking");
 function readPage(page, setId, fallbackCanvasId) {
   const entries = [];
@@ -27,8 +29,33 @@ function readPage(page, setId, fallbackCanvasId) {
   }
   return entries;
 }
+const paintsLayers = (manifest) => selectSequence(manifest).canvases.some(
+  (canvas) => asArray(canvas.items).some(
+    (page) => asArray(page == null ? void 0 : page.items).some(
+      (painting) => asArray(painting == null ? void 0 : painting.body).some(
+        (body) => [body, ...asArray(body == null ? void 0 : body.items)].some(
+          (image) => asArray(image == null ? void 0 : image.annotations).length > 0
+        )
+      )
+    )
+  )
+);
+function pageLabel(page, reference) {
+  for (const each of [page, reference]) if (each == null ? void 0 : each.label) return each.label;
+  for (const each of [page, reference]) {
+    const collection = asArray(each == null ? void 0 : each.partOf).find(
+      (part) => /AnnotationCollection/.test(String((part == null ? void 0 : part.type) ?? (part == null ? void 0 : part["@type"]))) && part.label
+    );
+    if (collection) return collection.label;
+  }
+  return void 0;
+}
+const collectionsOf = (page) => asArray(page == null ? void 0 : page.partOf).filter(
+  (part) => (part == null ? void 0 : part.id) && /AnnotationCollection/.test(String((part == null ? void 0 : part.type) ?? (part == null ? void 0 : part["@type"])))
+);
 const manifestSets = /* @__PURE__ */ new WeakMap();
 function selectManifestSets(manifest) {
+  var _a;
   if (!manifest) return [];
   let sets = manifestSets.get(manifest);
   if (!sets) {
@@ -39,7 +66,14 @@ function selectManifestSets(manifest) {
         const id = page.id ?? `${canvas.id}#annotations`;
         let set = byId.get(id);
         if (!set) {
-          set = { id, label: page.label, source: "manifest", entries: [] };
+          const collection = (_a = collectionsOf(page)[0]) == null ? void 0 : _a.id;
+          set = {
+            id,
+            label: pageLabel(page),
+            source: "manifest",
+            entries: [],
+            ...collection ? { collection } : {}
+          };
           byId.set(id, set);
         }
         set.entries.push(...readPage(page, id, canvas.id));
@@ -50,6 +84,83 @@ function selectManifestSets(manifest) {
   }
   return sets;
 }
+const manifestPages = /* @__PURE__ */ new WeakMap();
+const NO_PAGES = [];
+function selectAnnotationPages(manifest) {
+  if (!manifest) return NO_PAGES;
+  let pages = manifestPages.get(manifest);
+  if (!pages) {
+    pages = selectSequence(manifest).canvases.flatMap(
+      (canvas) => asArray(canvas.annotations).filter((page) => page == null ? void 0 : page.id).map((page) => ({
+        id: String(page.id),
+        canvasId: String(canvas.id),
+        fetched: Array.isArray(page.items)
+      }))
+    );
+    manifestPages.set(manifest, pages);
+  }
+  return pages;
+}
+const manifestCollections = /* @__PURE__ */ new WeakMap();
+const contentCollections = /* @__PURE__ */ new WeakMap();
+function selectAnnotationCollection(manifest, added = NO_SETS_ADDED) {
+  var _a;
+  if (!contentCollections.has(added)) {
+    const sets = added.filter((set) => set.content);
+    const content = (_a = sets[0]) == null ? void 0 : _a.content;
+    contentCollections.set(
+      added,
+      content ? {
+        id: content.id,
+        type: content.type,
+        ...content.label ? { label: content.label } : {},
+        pages: NO_PAGES,
+        entries: sets.flatMap((set) => set.entries)
+      } : null
+    );
+  }
+  return contentCollections.get(added) ?? manifestCollection(manifest);
+}
+const NO_SETS_ADDED = [];
+function manifestCollection(manifest) {
+  var _a;
+  if (!manifest) return null;
+  if (manifestCollections.has(manifest))
+    return manifestCollections.get(manifest);
+  const pages = selectSequence(manifest).canvases.flatMap(
+    (canvas) => asArray(canvas.annotations).flatMap(
+      (page) => collectionsOf(page).map((part) => ({ part, page, canvas }))
+    )
+  );
+  const id = (_a = pages[0]) == null ? void 0 : _a.part.id;
+  const found = id ? (() => {
+    var _a2, _b;
+    const own = pages.filter(({ part }) => part.id === id);
+    const label = (_a2 = own.find(({ part }) => part.label)) == null ? void 0 : _a2.part.label;
+    const total = Number((_b = own.find(({ part }) => part.total)) == null ? void 0 : _b.part.total);
+    const sets = selectManifestSets(manifest);
+    return {
+      id,
+      type: "AnnotationCollection",
+      ...label ? { label } : {},
+      ...total > 0 ? { total } : {},
+      pages: own.map(({ page, canvas }) => ({
+        id: String(page.id),
+        canvasId: String(canvas.id),
+        fetched: Array.isArray(page.items)
+      })),
+      // In the pages' order: a page's set is listed where its Canvas first names it.
+      entries: own.flatMap(
+        ({ page }) => {
+          var _a3;
+          return ((_a3 = sets.find((set) => set.id === page.id)) == null ? void 0 : _a3.entries) ?? [];
+        }
+      )
+    };
+  })() : null;
+  manifestCollections.set(manifest, found);
+  return found;
+}
 const allSets = /* @__PURE__ */ new WeakMap();
 const NO_SETS = [];
 function selectAnnotationSets(manifest, added) {
@@ -60,21 +171,32 @@ function selectAnnotationSets(manifest, added) {
   if (!byAdded) allSets.set(key, byAdded = /* @__PURE__ */ new Map());
   let sets = byAdded.get(added);
   if (!sets) {
-    sets = [...own, ...added];
+    const seen = new Set(own.map((set) => set.id));
+    sets = [
+      ...own,
+      ...added.filter((set) => !seen.has(set.id) && Boolean(seen.add(set.id)))
+    ];
     byAdded.set(added, sets);
   }
   return sets;
 }
 const drawnSets = /* @__PURE__ */ new WeakMap();
-function selectDrawnSets(manifest, added, searchSet) {
+function selectDrawnSets(manifest, added, searchSet, regions = null) {
   const sets = selectAnnotationSets(manifest, added);
-  if (!(searchSet == null ? void 0 : searchSet.entries.length)) return sets;
-  let bySearch = drawnSets.get(sets);
-  if (!bySearch) drawnSets.set(sets, bySearch = /* @__PURE__ */ new Map());
-  let drawn = bySearch.get(searchSet);
+  const search = (searchSet == null ? void 0 : searchSet.entries.length) ? searchSet : null;
+  if (!regions && !search) return sets;
+  let byRegions = drawnSets.get(sets);
+  if (!byRegions) drawnSets.set(sets, byRegions = /* @__PURE__ */ new Map());
+  let bySearch = byRegions.get(regions);
+  if (!bySearch) byRegions.set(regions, bySearch = /* @__PURE__ */ new Map());
+  let drawn = bySearch.get(search);
   if (!drawn) {
-    drawn = [...sets, searchSet];
-    bySearch.set(searchSet, drawn);
+    drawn = [
+      ...sets,
+      ...regions ? [regions] : [],
+      ...search ? [search] : []
+    ];
+    bySearch.set(search, drawn);
   }
   return drawn;
 }
@@ -118,6 +240,7 @@ function selectUnlistedSets(manifest, added, hidden, shown) {
   if (cached && cached.hidden === hidden) return cached.ids;
   const ids = [
     SEARCH_SET_ID,
+    CONTENTS_SET_ID,
     ...drawnHidden.filter((id) => !hidden.includes(id))
   ];
   unlistedOf.set(drawnHidden, { hidden, ids });
@@ -142,9 +265,15 @@ function findEntry(sets, id) {
   return null;
 }
 export {
+  CONTENTS_SET_ID,
   findEntry,
   manifestOfAnnotation,
+  pageLabel,
+  paintsLayers,
   readPage,
+  regionEntryId,
+  selectAnnotationCollection,
+  selectAnnotationPages,
   selectAnnotationSets,
   selectDrawnSets,
   selectHiddenSets,

package/dist/core/annotations-content.mjs

@@ -3,7 +3,14 @@ import { loadAnnotationSets } from "./annotation-collection.mjs";
 import { manifestOfAnnotation } from "./annotation-sets.mjs";
 import { CloverContentError, loadManifest } from "./load.mjs";
 async function annotationsContent(json, options) {
-  const annotationSets = await loadAnnotationSets(json, options);
+  const content = {
+    id: String(json.id ?? ""),
+    type: /Collection/.test(String(json.type ?? json["@type"])) ? "AnnotationCollection" : "AnnotationPage",
+    ...json.label ? { label: json.label } : {}
+  };
+  const annotationSets = (await loadAnnotationSets(json, options)).map(
+    (set) => ({ ...set, content })
+  );
   const entries = annotationSets.flatMap((set) => set.entries);
   const first = entries.find(
     (entry) => options.manifestId && manifestOfAnnotation(entry.annotation) === options.manifestId

package/dist/core/annotations.mjs

@@ -42,9 +42,16 @@ function readTarget(target) {
   for (const raw of asArray(target.selector)) {
     const selector = raw;
     if ((selector == null ? void 0 : selector.type) === "PointSelector") {
+      const [x, y, t] = [
+        selector.x,
+        selector.y,
+        selector.instant ?? selector.t
+      ].map(Number);
+      const placed = Number.isFinite(x) && Number.isFinite(y);
       return {
         id: source.id,
-        point: { x: Number(selector.x), y: Number(selector.y) }
+        ...placed ? { point: { x, y } } : {},
+        ...Number.isFinite(t) ? { t: String(t) } : {}
       };
     }
     if ((selector == null ? void 0 : selector.type) === "SvgSelector" && selector.value) {

package/dist/core/choice-key.mjs

@@ -0,0 +1,5 @@
+"use client";
+const choiceKey = (canvasId, annotationId, page, index, body) => `${canvasId}|${annotationId ?? `${page}:${index}`}|${body}`;
+export {
+  choiceKey
+};

package/dist/core/clover.mjs

@@ -1,9 +1,9 @@
 "use client";
-import { findEntry, selectDrawnSets, selectHiddenSets, manifestOfAnnotation, readPage } from "./annotation-sets.mjs";
+import { findEntry, selectDrawnSets, selectHiddenSets, manifestOfAnnotation, readPage, paintsLayers } 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 { selectSequence, selectVisibleCanvases, selectCanvas, 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) {
@@ -30,13 +30,17 @@ const INITIAL = {
   error: null,
   manifest: null,
   collection: null,
+  throughCollection: false,
   canvasId: null,
   target: null,
   annotationId: null,
   hiddenSets: [],
   shownSets: [],
   addedSets: [],
-  search: NO_SEARCH
+  search: NO_SEARCH,
+  regions: null,
+  targets: null,
+  targetIndex: null
 };
 function createClover(options = {}) {
   const store = createStore(INITIAL);
@@ -45,33 +49,54 @@ function createClover(options = {}) {
   const captions = createChannel(null);
   const highlight = createChannel(null);
   const chapter = createChannel(null);
+  const found = createChannel(null);
   let annotating = null;
   let searching = null;
+  let layerSets = [];
   let hostSets = [];
   let stateSets = [];
+  let arrivals = 0;
   let pending = null;
-  const added = () => hostSets.length || stateSets.length ? [...hostSets, ...stateSets] : INITIAL.addedSets;
+  let contentTargets = null;
+  let pendingPlace = null;
+  const shownAs = (address, id) => {
+    if (!contentTargets || address === id) return;
+    contentTargets = {
+      ...contentTargets,
+      items: contentTargets.items.map(
+        (target) => target.manifestId === address && target.manifestAs !== id ? { ...target, manifestAs: id } : target
+      )
+    };
+  };
+  const isTargetShown = (target) => {
+    var _a;
+    const shown = (_a = store.get().manifest) == null ? void 0 : _a.id;
+    return Boolean(shown) && (shown === target.manifestId || shown === target.manifestAs);
+  };
+  const added = () => layerSets.length || hostSets.length || stateSets.length ? [...layerSets, ...hostSets, ...stateSets] : INITIAL.addedSets;
   let request = options.request;
   let loading = null;
   const requested = /* @__PURE__ */ new Set();
   let pageScope = "view";
   let allHeld = 0;
+  const embedReferenced = (canvas, list, pageId) => {
+    if (requested.has(pageId)) return;
+    requested.add(pageId);
+    const signal = loading == null ? void 0 : loading.signal;
+    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));
+  };
   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));
-    }
+    ))
+      embedReferenced(canvas, list, pageId);
   };
   store.subscribe(embedVisiblePages);
   const arrive = (manifest, collection, deepLink, initial, pick) => {
@@ -84,16 +109,31 @@ function createClover(options = {}) {
     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;
+    const at = ++arrivals;
+    layerSets = [];
     store.set({
       status: "ready",
       search: NO_SEARCH,
+      regions: null,
       manifest,
       collection,
       canvasId,
       target: arrival && arrival.canvasId === canvasId ? arrival : null,
       addedSets: added(),
-      annotationId: picked
+      annotationId: picked,
+      targets: contentTargets
     });
+    const structures = manifest == null ? void 0 : manifest.structures;
+    if (Array.isArray(structures) && JSON.stringify(structures).includes("xywh="))
+      void import("./range-regions.mjs").then(({ contentsSet }) => {
+        if (arrivals === at) store.set({ regions: contentsSet(manifest) });
+      });
+    if (paintsLayers(manifest))
+      void import("./image-layers.mjs").then(({ imageLayers }) => {
+        if (arrivals !== at) return;
+        layerSets = imageLayers(manifest);
+        store.set({ addedSets: added() });
+      });
     if (canvasId && canvasId !== initial.canvasId) {
       (_c = options.onCanvasChange) == null ? void 0 : _c.call(options, canvasId);
     }
@@ -154,6 +194,11 @@ function createClover(options = {}) {
       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;
+      store.set({ throughCollection: Boolean(loaded.collection) });
+      contentTargets = loaded.targets ?? null;
+      if (contentTargets)
+        shownAs(contentTargets.items[0].manifestId, loaded.manifest.id);
+      store.set({ targetIndex: contentTargets ? 0 : null });
       arrive(
         loaded.manifest,
         loaded.collection ?? null,
@@ -189,7 +234,7 @@ function createClover(options = {}) {
       }
     );
   };
-  const show = async (member, canvasId) => {
+  const show = async (member, place) => {
     if (member.type === "Collection") {
       await load(member.id);
       return store.get().status === "ready";
@@ -199,13 +244,16 @@ function createClover(options = {}) {
     const pick = pending;
     pending = null;
     const waiting = pick ? findEntry(stateSets, pick) : null;
+    const placed = typeof place === "string" ? { canvasId: place } : place ?? pendingPlace;
+    pendingPlace = null;
     try {
       const next = await loadManifest(member, { request, signal });
       if (signal.aborted) return false;
+      shownAs(member.id, next.id);
       arrive(
         next,
         collection,
-        waiting ? { canvasId: waiting.canvasId } : canvasId ? { canvasId } : void 0,
+        waiting ? { canvasId: waiting.canvasId } : placed ?? void 0,
         {},
         pick
       );
@@ -222,6 +270,7 @@ function createClover(options = {}) {
     captions,
     highlight,
     chapter,
+    found,
     get request() {
       return request;
     },
@@ -253,6 +302,32 @@ function createClover(options = {}) {
         (_c = options.onManifestChange) == null ? void 0 : _c.call(options, store.get().manifest.id);
       }
     },
+    goToTarget(index) {
+      var _a, _b, _c;
+      const target = (_a = store.get().targets) == null ? void 0 : _a.items[index];
+      if (!target) return;
+      store.set({ targetIndex: index });
+      const place = target.canvasId ? {
+        canvasId: target.canvasId,
+        ...target.region && { region: target.region },
+        ...target.time !== void 0 && { time: target.time }
+      } : null;
+      if (isTargetShown(target)) {
+        if (place) navigate(place.canvasId, place);
+        return;
+      }
+      if ((_b = options.isManifestControlled) == null ? void 0 : _b.call(options)) {
+        pendingPlace = place;
+        (_c = options.onManifestChange) == null ? void 0 : _c.call(options, target.manifestId);
+        return;
+      }
+      void show(memberOf(target.manifestId), place ?? void 0).then(
+        (shown) => {
+          var _a2;
+          return shown && ((_a2 = options.onManifestChange) == null ? void 0 : _a2.call(options, target.manifestId));
+        }
+      );
+    },
     async syncManifest(id) {
       if (!id || isShown(id) || store.get().status !== "ready") return;
       await show(memberOf(id));
@@ -282,13 +357,14 @@ function createClover(options = {}) {
       if (canvasId) store.set({ canvasId });
     },
     selectAnnotation(id) {
-      const { manifest, addedSets, canvasId, search } = store.get();
+      const { manifest, addedSets, canvasId, search, regions } = store.get();
       const entry = findEntry(
-        selectDrawnSets(manifest, addedSets, search.set),
+        selectDrawnSets(manifest, addedSets, search.set, regions),
         id
       );
       store.set({ annotationId: entry ? id : null });
       if (!entry) return;
+      found.emit(id);
       const { hiddenSets, shownSets } = store.get();
       if (entry.setId !== SEARCH_SET_ID && selectHiddenSets(manifest, addedSets, hiddenSets, shownSets).includes(
         entry.setId
@@ -371,6 +447,15 @@ function createClover(options = {}) {
       pageScope = scope;
       embedVisiblePages();
     },
+    fetchAnnotationPages(pageIds) {
+      const { manifest } = store.get();
+      if (!manifest || !pageIds.length) return;
+      const wanted = new Set(pageIds);
+      for (const [canvas, list, pageId] of referencedPages(
+        selectSequence(manifest).canvases
+      ))
+        if (wanted.has(pageId)) embedReferenced(canvas, list, pageId);
+    },
     holdAllAnnotationPages() {
       allHeld++;
       embedVisiblePages();

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

@@ -35,8 +35,39 @@ const collectionOf = (resource) => asArray(resource == null ? void 0 : resource.
   (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 all = json.type === "Annotation" ? asArray(json.target) : [json];
+  const first = all[0] ? resolveTarget(all[0], json) : null;
+  if (!first || all.length < 2) return first;
+  const base = typeof json.id === "string" ? json.id : "content-state";
+  const items = all.flatMap((target, index) => {
+    var _a, _b, _c;
+    const resolved = index === 0 ? first : resolveTarget(target, json);
+    const manifestId = (resolved == null ? void 0 : resolved.type) === "Manifest" ? resolved.id : resolved == null ? void 0 : resolved.manifestId;
+    if (!resolved || !manifestId) return [];
+    return [
+      {
+        id: `${base}#target-${index + 1}`,
+        manifestId,
+        ...((_a = resolved.target) == null ? void 0 : _a.canvasId) && {
+          canvasId: resolved.target.canvasId
+        },
+        ...((_b = resolved.target) == null ? void 0 : _b.region) && { region: resolved.target.region },
+        ...((_c = resolved.target) == null ? void 0 : _c.time) !== void 0 && {
+          time: resolved.target.time
+        }
+      }
+    ];
+  });
+  return items.length > 1 ? {
+    ...first,
+    targets: {
+      id: base,
+      ...json.label && typeof json.label === "object" ? { label: json.label } : {},
+      items
+    }
+  } : first;
+}
+function resolveTarget(target, json) {
   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;

package/dist/core/dates-format.mjs

@@ -0,0 +1,30 @@
+"use client";
+const FORMATS = {
+  year: { year: "numeric" },
+  month: { year: "numeric", month: "long" },
+  day: { dateStyle: "long" },
+  time: { dateStyle: "long", timeStyle: "short" }
+};
+function formatDate({ at, precision }, locale) {
+  const options = { ...FORMATS[precision], timeZone: "UTC" };
+  try {
+    return new Intl.DateTimeFormat(locale, options).format(at);
+  } catch {
+    return new Intl.DateTimeFormat("en", options).format(at);
+  }
+}
+function dateTimeOf({ at, precision }, written) {
+  const year = at.getUTCFullYear();
+  if (precision === "time" || year < 0)
+    return (written == null ? void 0 : written.trim()) || at.toISOString();
+  const two = (n) => String(n).padStart(2, "0");
+  return [
+    String(year).padStart(4, "0"),
+    ...precision === "year" ? [] : [two(at.getUTCMonth() + 1)],
+    ...precision === "day" ? [two(at.getUTCDate())] : []
+  ].join("-");
+}
+export {
+  dateTimeOf,
+  formatDate
+};

package/dist/core/dates.mjs

@@ -0,0 +1,19 @@
+"use client";
+const DATE_TIME = /^(-?\d{4,})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?/;
+function readDate(value, precision) {
+  if (typeof value !== "string") return null;
+  const parts = DATE_TIME.exec(value.trim());
+  if (!parts) return null;
+  const [year, month, day, hours = 0, minutes = 0, seconds = 0] = parts.slice(1, 7).map((part) => part === void 0 ? void 0 : Number(part));
+  const at = new Date(Date.UTC(2e3, month - 1, day, hours, minutes, seconds));
+  at.setUTCFullYear(year);
+  if (at.getUTCMonth() !== month - 1 || at.getUTCDate() !== day) return null;
+  const midnight = !hours && !minutes && !seconds && !Number(parts[7] ?? 0);
+  return {
+    at,
+    precision: precision ?? (!midnight ? "time" : day !== 1 ? "day" : month !== 1 ? "month" : "year")
+  };
+}
+export {
+  readDate
+};

package/dist/core/geo.mjs

@@ -34,6 +34,22 @@ function featuresOf(geo) {
   if (GEOMETRIES.has(value.type)) return [{ type: "Feature", geometry: value }];
   return [];
 }
+function closed(geometry) {
+  const ring = (points) => {
+    if (!Array.isArray(points) || points.length < 3) return points;
+    const [first, last] = [points[0], points[points.length - 1]];
+    const same = Array.isArray(first) && Array.isArray(last) && first[0] === last[0] && first[1] === last[1];
+    return same ? points : [...points, first];
+  };
+  const rings = (polygon) => Array.isArray(polygon) ? polygon.map(ring) : polygon;
+  if ((geometry == null ? void 0 : geometry.type) === "Polygon")
+    return { ...geometry, coordinates: rings(geometry.coordinates) };
+  if ((geometry == null ? void 0 : geometry.type) === "MultiPolygon" && Array.isArray(geometry.coordinates))
+    return { ...geometry, coordinates: geometry.coordinates.map(rings) };
+  if ((geometry == null ? void 0 : geometry.type) === "GeometryCollection" && geometry.geometries)
+    return { ...geometry, geometries: geometry.geometries.map(closed) };
+  return geometry;
+}
 function flatten(feature, owner, language) {
   const own = feature.properties ?? {};
   const properties = {};
@@ -50,10 +66,13 @@ function flatten(feature, owner, language) {
     if (title.lang) properties.titleLang = title.lang;
   }
   if (owner.canvasId) properties.canvasId = owner.canvasId;
+  if (owner.annotationId) properties.annotationId = owner.annotationId;
+  if (owner.manifestId) properties.manifestId = owner.manifestId;
+  if (typeof owner.navDate === "string") properties.navDate = owner.navDate;
   return {
     type: "Feature",
     ...feature.id != null ? { id: feature.id } : {},
-    geometry: feature.geometry,
+    geometry: closed(feature.geometry),
     properties
   };
 }
@@ -75,17 +94,39 @@ function navPlaceOf(manifest, collection = null, language) {
   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 });
+  if (c == null ? void 0 : c.navPlace) add(c.navPlace, { label: c.label, navDate: c.navDate });
   const m = manifest;
-  if (m.navPlace) add(m.navPlace, { label: m.label });
+  let own = false;
+  for (const member of asArray(c == null ? void 0 : c.items)) {
+    if (typeof (member == null ? void 0 : member.id) !== "string") continue;
+    const open = member.id === m.id;
+    const place = open && m.navPlace ? m.navPlace : member.navPlace;
+    if (!place) continue;
+    own || (own = open && place === m.navPlace);
+    add(place, {
+      label: open ? m.label : member.label,
+      manifestId: member.id,
+      navDate: open ? m.navDate ?? member.navDate : member.navDate
+    });
+  }
+  if (m.navPlace && !own)
+    add(m.navPlace, { label: m.label, navDate: m.navDate });
   for (const canvas of selectSequence(manifest).canvases) {
     if (canvas.navPlace) {
-      add(canvas.navPlace, { label: canvas.label, canvasId: canvas.id });
+      add(canvas.navPlace, {
+        label: canvas.label,
+        canvasId: canvas.id,
+        navDate: canvas.navDate
+      });
     }
     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 };
+      const owner = {
+        label: annotation.label ?? canvas.label,
+        canvasId,
+        ...typeof annotation.id === "string" ? { annotationId: annotation.id } : {}
+      };
       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") {