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

package/dist/lib/renderer/sources/imageService.mjs

@@ -0,0 +1,160 @@
+"use client";
+import { cloverFetch } from "../../../core/request.mjs";
+const DECODABLE = ["jpg", "png", "webp", "gif"];
+class ImageServiceError extends Error {
+  constructor(message, url, status) {
+    super(message);
+    this.url = url;
+    this.status = status;
+    this.name = "ImageServiceError";
+  }
+}
+function serviceBase(uri) {
+  return uri.replace(/\/info\.json$/, "").replace(/\/+$/, "");
+}
+function findImageServiceId(service) {
+  const services = Array.isArray(service) ? service : service ? [service] : [];
+  for (const candidate of services) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const s = candidate;
+    const type = String(s.type ?? s["@type"] ?? "");
+    const profile = JSON.stringify(s.profile ?? "");
+    const isImageService = /ImageService/i.test(type) || /iiif\.io\/api\/image/.test(profile) || /^"level[012]"$/.test(profile) || !type && !s.profile;
+    const id = s["@id"] ?? s.id;
+    if (isImageService && typeof id === "string") return serviceBase(id);
+  }
+  return void 0;
+}
+function parseInfo(json, requestedId) {
+  if (!json || typeof json !== "object") {
+    throw new ImageServiceError(
+      "info.json is not an object",
+      requestedId ?? ""
+    );
+  }
+  const doc = json;
+  const version = detectVersion(doc);
+  const rawId = version === 3 ? doc.id ?? doc["@id"] : doc["@id"] ?? doc.id;
+  const id = serviceBase(rawId ?? requestedId ?? "");
+  const width = Number(doc.width);
+  const height = Number(doc.height);
+  if (!id || !(width > 0) || !(height > 0)) {
+    throw new ImageServiceError(
+      "info.json is missing id, width or height",
+      requestedId ?? id
+    );
+  }
+  const profiles = Array.isArray(doc.profile) ? doc.profile : [doc.profile];
+  const complianceUri = profiles.find((p) => typeof p === "string");
+  const profileObjects = profiles.filter(
+    (p) => !!p && typeof p === "object"
+  );
+  const level = detectLevel(complianceUri);
+  const supports = /* @__PURE__ */ new Set([
+    ...Array.isArray(doc.extraFeatures) ? doc.extraFeatures : [],
+    ...profileObjects.flatMap(
+      (p) => Array.isArray(p.supports) ? p.supports : []
+    )
+  ]);
+  const formats = [
+    ...Array.isArray(doc.preferredFormats) ? doc.preferredFormats : []
+  ].map((f) => String(f).toLowerCase());
+  const format = formats.find((f) => DECODABLE.includes(f)) ?? "jpg";
+  const maxOf = (key) => {
+    var _a;
+    const value = doc[key] ?? ((_a = profileObjects.find((p) => p[key] !== void 0)) == null ? void 0 : _a[key]);
+    return Number(value) > 0 ? Number(value) : void 0;
+  };
+  let maxWidth = maxOf("maxWidth");
+  let maxHeight = maxOf("maxHeight");
+  if (maxWidth && !maxHeight) maxHeight = maxWidth;
+  if (maxHeight && !maxWidth) maxWidth = void 0;
+  return {
+    id,
+    version,
+    level,
+    width,
+    height,
+    tiles: parseTiles(doc.tiles),
+    sizes: parseSizes(doc.sizes),
+    maxWidth,
+    maxHeight,
+    maxArea: maxOf("maxArea"),
+    regionByPx: level >= 1 || supports.has("regionByPx"),
+    sizeByW: level >= 1 || supports.has("sizeByW") || supports.has("sizeByWh"),
+    format,
+    quality: "default"
+  };
+}
+function detectVersion(doc) {
+  const contexts = [].concat(doc["@context"] ?? []).map(String);
+  if (contexts.some((c) => c.includes("/image/3"))) return 3;
+  if (contexts.some((c) => c.includes("/image/2"))) return 2;
+  if (doc.type === "ImageService3") return 3;
+  return doc["@id"] ? 2 : 3;
+}
+function detectLevel(compliance) {
+  const match = compliance == null ? void 0 : compliance.match(/level([012])/);
+  return match ? Number(match[1]) : 0;
+}
+function parseTiles(tiles) {
+  if (!Array.isArray(tiles)) return [];
+  return tiles.map((t) => {
+    const width = Number(t == null ? void 0 : t.width);
+    const height = Number((t == null ? void 0 : t.height) ?? (t == null ? void 0 : t.width));
+    const scaleFactors = (Array.isArray(t == null ? void 0 : t.scaleFactors) ? t.scaleFactors : [1]).map(Number).filter((s) => s > 0).sort((a, b) => a - b);
+    return { width, height, scaleFactors };
+  }).filter((t) => t.width > 0 && t.height > 0 && t.scaleFactors.length);
+}
+function parseSizes(sizes) {
+  if (!Array.isArray(sizes)) return [];
+  return sizes.map((s) => ({ width: Number(s == null ? void 0 : s.width), height: Number(s == null ? void 0 : s.height) })).filter((s) => s.width > 0 && s.height > 0).sort((a, b) => a.width - b.width);
+}
+function imageRequestUrl(info, region, width, height, quality = info.quality) {
+  const isFull = region.x === 0 && region.y === 0 && region.width === info.width && region.height === info.height;
+  const regionPart = isFull ? "full" : `${region.x},${region.y},${region.width},${region.height}`;
+  const isFullSize = isFull && width === info.width && height === info.height;
+  let sizePart;
+  if (info.version === 3) {
+    sizePart = isFullSize ? "max" : `${width},${height}`;
+  } else {
+    sizePart = isFullSize ? "full" : `${width},`;
+  }
+  return `${info.id}/${regionPart}/${sizePart}/0/${quality}.${info.format}`;
+}
+function alternateQuality(info) {
+  return info.version === 2 && info.level === 0 ? "native" : void 0;
+}
+const infoCache = /* @__PURE__ */ new Map();
+function fetchInfo(serviceUri, { request } = {}) {
+  const base = serviceBase(serviceUri);
+  const cached = infoCache.get(base);
+  if (cached) return cached;
+  const url = `${base}/info.json`;
+  const pending = cloverFetch(request, url, {
+    headers: { Accept: "application/ld+json, application/json" }
+  }).then(async (response) => {
+    if (!response.ok) {
+      throw new ImageServiceError(
+        `info.json request failed with ${response.status}`,
+        url,
+        response.status
+      );
+    }
+    return parseInfo(await response.json(), base);
+  }).catch((error) => {
+    infoCache.delete(base);
+    throw error;
+  });
+  infoCache.set(base, pending);
+  return pending;
+}
+export {
+  ImageServiceError,
+  alternateQuality,
+  fetchInfo,
+  findImageServiceId,
+  imageRequestUrl,
+  parseInfo,
+  serviceBase
+};

package/dist/lib/renderer/sources/sizedImage.mjs

@@ -0,0 +1,38 @@
+"use client";
+import { imageRequestUrl } from "./imageService.mjs";
+function sizedImageUrl(info, size, share) {
+  const clip = (value, limit) => Math.min(Math.max(Math.round(value), 0), limit);
+  const x = share ? clip(share.x * info.width, info.width - 1) : 0;
+  const y = share ? clip(share.y * info.height, info.height - 1) : 0;
+  const region = {
+    x,
+    y,
+    width: share ? Math.max(1, clip(share.width * info.width, info.width - x)) : info.width,
+    height: share ? Math.max(1, clip(share.height * info.height, info.height - y)) : info.height
+  };
+  const whole = region.width === info.width && region.height === info.height;
+  if (!whole && !info.regionByPx) return null;
+  if (info.sizeByW) {
+    let scale = Math.min(1, size / Math.max(region.width, region.height));
+    if (info.maxWidth) scale = Math.min(scale, info.maxWidth / region.width);
+    if (info.maxHeight) scale = Math.min(scale, info.maxHeight / region.height);
+    if (info.maxArea)
+      scale = Math.min(
+        scale,
+        Math.sqrt(info.maxArea / (region.width * region.height))
+      );
+    return imageRequestUrl(
+      info,
+      region,
+      Math.max(1, Math.floor(region.width * scale)),
+      Math.max(1, Math.floor(region.height * scale))
+    );
+  }
+  if (!whole) return null;
+  const sizes = [...info.sizes].sort((a, b) => a.width - b.width);
+  const pick = sizes.find((s) => Math.max(s.width, s.height) >= size) ?? sizes.at(-1) ?? { width: info.width, height: info.height };
+  return imageRequestUrl(info, region, pick.width, pick.height);
+}
+export {
+  sizedImageUrl
+};

package/dist/lib/renderer/sources/tilePyramid.mjs

@@ -0,0 +1,172 @@
+"use client";
+import { alternateQuality, imageRequestUrl } from "./imageService.mjs";
+const DERIVED_TILE_SIZE = 512;
+const MAX_SINGLE_IMAGE_PIXELS = 16e6;
+function staticPyramid(url, width, height) {
+  const level = {
+    scaleFactor: 1,
+    width,
+    height,
+    tileWidth: width,
+    tileHeight: height,
+    cols: 1,
+    rows: 1
+  };
+  return {
+    width,
+    height,
+    levels: [level],
+    tile: (address) => ({
+      ...address,
+      url,
+      region: { x: 0, y: 0, width, height }
+    })
+  };
+}
+function servicePyramid(info) {
+  const { width: W, height: H } = info;
+  const levels = [];
+  const arbitrary = info.regionByPx && info.sizeByW;
+  const tileLevel = (s, tw, th) => {
+    const width = Math.ceil(W / s);
+    const height = Math.ceil(H / s);
+    return {
+      scaleFactor: s,
+      width,
+      height,
+      tileWidth: tw,
+      tileHeight: th,
+      cols: Math.ceil(width / tw),
+      rows: Math.ceil(height / th)
+    };
+  };
+  const wholeLevel = (width, height) => ({
+    scaleFactor: W / width,
+    width,
+    height,
+    tileWidth: width,
+    tileHeight: height,
+    cols: 1,
+    rows: 1,
+    whole: true
+  });
+  const spec = info.tiles[0];
+  if (spec) {
+    for (const s of spec.scaleFactors) {
+      levels.push(tileLevel(s, spec.width, spec.height));
+    }
+  } else if (arbitrary) {
+    for (let s = 1; ; s *= 2) {
+      const level = tileLevel(s, DERIVED_TILE_SIZE, DERIVED_TILE_SIZE);
+      levels.push(level);
+      if (level.cols === 1 && level.rows === 1) break;
+    }
+  }
+  const coarsestTile = Math.max(0, ...levels.map((l) => l.scaleFactor));
+  for (const size of info.sizes) {
+    const s = W / size.width;
+    if (!withinLimits(info, size.width, size.height)) continue;
+    if (s > coarsestTile + 1e-9)
+      levels.push(wholeLevel(size.width, size.height));
+  }
+  const coarsest = levels.reduce(
+    (best, l) => !best || l.scaleFactor > best.scaleFactor ? l : best,
+    null
+  );
+  if (coarsest && coarsest.cols * coarsest.rows > 1 && info.sizeByW) {
+    const s = Math.max(W, H) / DERIVED_TILE_SIZE;
+    levels.push(wholeLevel(Math.ceil(W / s), Math.ceil(H / s)));
+  }
+  if (!levels.length || !spec && !arbitrary && W * H <= MAX_SINGLE_IMAGE_PIXELS) {
+    if (!levels.some((l) => l.scaleFactor === 1)) levels.push(wholeLevel(W, H));
+  }
+  const ordered = dedupe(levels).sort((a, b) => b.scaleFactor - a.scaleFactor);
+  const fallbackQuality = alternateQuality(info);
+  return {
+    width: W,
+    height: H,
+    levels: ordered,
+    tile(address) {
+      const level = ordered[address.level];
+      const s = level.scaleFactor;
+      const isWhole = level.cols === 1 && level.rows === 1;
+      let region;
+      let w;
+      let h;
+      if (isWhole) {
+        region = { x: 0, y: 0, width: W, height: H };
+        w = level.width;
+        h = level.height;
+      } else {
+        const x = Math.round(address.col * level.tileWidth * s);
+        const y = Math.round(address.row * level.tileHeight * s);
+        region = {
+          x,
+          y,
+          width: Math.min(Math.round(level.tileWidth * s), W - x),
+          height: Math.min(Math.round(level.tileHeight * s), H - y)
+        };
+        w = Math.ceil(region.width / s);
+        h = Math.ceil(region.height / s);
+      }
+      return {
+        ...address,
+        region,
+        url: imageRequestUrl(info, region, w, h),
+        fallbackUrl: fallbackQuality ? imageRequestUrl(info, region, w, h, fallbackQuality) : void 0
+      };
+    }
+  };
+}
+function withinLimits(info, w, h) {
+  if (info.maxWidth && w > info.maxWidth) return false;
+  if (info.maxHeight && h > info.maxHeight) return false;
+  if (info.maxArea && w * h > info.maxArea) return false;
+  return true;
+}
+function dedupe(levels) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const level of levels) {
+    const key = `${level.width}x${level.height}`;
+    const existing = seen.get(key);
+    if (!existing || existing.cols * existing.rows < level.cols * level.rows) {
+      seen.set(key, level);
+    }
+  }
+  return [...seen.values()];
+}
+function chooseLevel(pyramid, imagePixelsPerDevicePixel) {
+  const levels = pyramid.levels;
+  for (let i = 0; i < levels.length; i++) {
+    if (levels[i].scaleFactor <= imagePixelsPerDevicePixel * (1 + 1e-6)) {
+      return i;
+    }
+  }
+  return levels.length - 1;
+}
+function tilesInRegion(pyramid, level, area) {
+  const l = pyramid.levels[level];
+  const spanX = l.tileWidth * l.scaleFactor;
+  const spanY = l.tileHeight * l.scaleFactor;
+  const x0 = Math.max(0, area.x);
+  const y0 = Math.max(0, area.y);
+  const x1 = Math.min(pyramid.width, area.x + area.width);
+  const y1 = Math.min(pyramid.height, area.y + area.height);
+  if (x1 <= x0 || y1 <= y0) return [];
+  const c0 = Math.max(0, Math.floor(x0 / spanX));
+  const c1 = Math.min(l.cols - 1, Math.floor((x1 - 1e-9) / spanX));
+  const r0 = Math.max(0, Math.floor(y0 / spanY));
+  const r1 = Math.min(l.rows - 1, Math.floor((y1 - 1e-9) / spanY));
+  const tiles = [];
+  for (let row = r0; row <= r1; row++) {
+    for (let col = c0; col <= c1; col++) tiles.push({ level, col, row });
+  }
+  return tiles;
+}
+export {
+  DERIVED_TILE_SIZE,
+  chooseLevel,
+  servicePyramid,
+  staticPyramid,
+  tilesInRegion
+};

package/dist/lib/time.mjs

@@ -0,0 +1,21 @@
+"use client";
+function formatTime(seconds) {
+  const total = Math.max(0, Math.floor(seconds || 0));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = String(total % 60).padStart(2, "0");
+  return h ? `${h}:${String(m).padStart(2, "0")}:${s}` : `${m}:${s}`;
+}
+function playFrom(element, seconds) {
+  var _a;
+  element.currentTime = seconds;
+  if (!element.paused) return;
+  try {
+    void ((_a = element.play()) == null ? void 0 : _a.catch(() => void 0));
+  } catch {
+  }
+}
+export {
+  formatTime,
+  playFrom
+};

package/dist/map/index.d.mts

@@ -0,0 +1,184 @@
+// Generated by dts-bundle-generator v8.0.1
+
+import React from 'react';
+
+/**
+ * IIIF language maps as text: the closest language to the reader's, and that language's
+ * tag, so the text can carry a `lang` attribute.
+ */
+export type LanguageMapLike = string | Record<string, string[] | string | undefined> | null | undefined;
+/**
+ * Whether a Manifest has anything to put on a map: navPlace on the Collection, Manifest,
+ * a Canvas or an annotation, a GeoJSON annotation body, or a georeferencing annotation.
+ * Only a look, never a read: the panel asks it to offer a Map tab, and the reading
+ * (`core/geo.ts`) belongs to the map entry, so an app without a map carries none of it.
+ */
+export declare function hasMapData(manifest: Manifest | null, collection?: Collection | null): boolean;
+/**
+ * Where a IIIF resource is, read for a map: navPlace (on a Collection, Manifest, Canvas
+ * or Annotation, and annotation bodies that are GeoJSON), and Georeference Extension
+ * annotations, reduced to what a basic overlay needs. Framework-free and small: the map
+ * itself, and MapLibre, load only when a `Map` is shown.
+ *
+ * - navPlace: https://iiif.io/api/extension/navplace/
+ * - Georeference: https://iiif.io/api/extension/georef/
+ */
+export type Position = [
+	number,
+	number
+];
+export interface GeoGeometry {
+	type: string;
+	coordinates?: unknown;
+	geometries?: GeoGeometry[];
+}
+export interface MapFeature {
+	type: "Feature";
+	id?: string | number;
+	geometry: GeoGeometry;
+	/**
+	 * Flat, for MapLibre (which turns nested objects into strings): the text to show and
+	 * its language, the Canvas it belongs to, and any simplestyle keys it carried (`fill`,
+	 * `stroke`, …).
+	 */
+	properties: Record<string, string | number | boolean> & {
+		title?: string;
+		titleLang?: string;
+		canvasId?: string;
+	};
+}
+export interface MapFeatureCollection {
+	type: "FeatureCollection";
+	features: MapFeature[];
+}
+/** A georeferenced image, reduced to an affine overlay. */
+export interface Georeference {
+	id: string;
+	/** The Canvas it georeferences, when it targets one. */
+	canvasId?: string;
+	/** Ground control points: image pixel [x, y] ↔ [longitude, latitude]. */
+	points: Array<{
+		resource: Position;
+		geo: Position;
+	}>;
+	/** The extent the points are measured in: the Canvas, or the image service. */
+	width: number;
+	height: number;
+	/** The part of the image that is map (an SvgSelector polygon), in the same units. */
+	mask?: Position[];
+	/** Its name: the annotation's label, or the Canvas's. */
+	label?: LanguageMapLike;
+	/** What to draw: an image body (or a bare image service), sized by `overlayImageUrl`. */
+	image: Record<string, unknown>;
+}
+export type Json = Record<string, any>;
+/**
+ * Every navPlace feature of the Root's resource: the Collection's, the Manifest's, each
+ * Canvas's, and each loaded annotation's (its `navPlace`, or a GeoJSON body as Cookbook
+ * 0139 has). A feature from a Canvas or annotation names that Canvas. Memoized on the
+ * Manifest (and the Collection), so the same collection comes back while nothing changes.
+ */
+export declare function navPlaceOf(manifest: Manifest | null, collection?: Collection | null, language?: string): MapFeatureCollection;
+/**
+ * One Georeference Extension annotation as an overlay: its control points, the extent
+ * they are measured in, its mask, and the image to draw (the Canvas's painted image, or
+ * the image service it targets directly). Null when it cannot be drawn: fewer than three
+ * points, no extent, or nothing to draw.
+ */
+export declare function readGeoreference(annotation: Json, canvas?: Json): Georeference | null;
+/**
+ * The georeferenced images of the Manifest's Canvases, from their loaded annotation pages.
+ * Memoized on the Manifest: embedding a fetched page makes a new one.
+ */
+export declare function georeferencesOf(manifest: Manifest | null): Georeference[];
+/**
+ * The first-order polynomial (affine) transform that best fits the control points, image
+ * pixels to [longitude, latitude], by least squares in Web Mercator. Exact for three
+ * points. Null when the points are collinear.
+ */
+export declare function affineTransform(points: Georeference["points"]): ((pixel: Position) => Position) | null;
+/**
+ * Where the image's corners land, in the order MapLibre's image and canvas sources take
+ * them: top left, top right, bottom right, bottom left. Null when the points do not fix
+ * a transform.
+ */
+export declare function cornersOf(georeference: Georeference): [
+	Position,
+	Position,
+	Position,
+	Position
+] | null;
+/** The [[west, south], [east, north]] that holds the features and the overlays. */
+export declare function boundsOf(features: MapFeature[], overlays?: Georeference[]): [
+	Position,
+	Position
+] | null;
+/**
+ * How Clover asks for things: one setting for every request it makes — the IIIF resource,
+ * referenced annotation pages, `info.json`, tiles, captions and HLS segments.
+ *
+ * A `<video>` or `<img>` element cannot send headers, so where Clover must use one (media
+ * without HLS, an image served without CORS) only `credentials` applies.
+ */
+export interface CloverRequest {
+	/** Cookies and HTTP authentication: `"include"` sends them cross-origin. */
+	credentials?: RequestCredentials;
+	/** Extra headers, such as `Authorization`. They force a CORS preflight. */
+	headers?: Record<string, string>;
+	/** Your own `fetch`, to sign, log or proxy requests. */
+	fetch?: typeof fetch;
+}
+/**
+ * Turning whatever a `Root` is handed into a Manifest to show.
+ *
+ * `iiifContent` may be a URL, a IIIF resource object (Presentation 2, 3 or 4), or a content
+ * state (JSON or base64url). The resource may be a Manifest, a Collection (its first
+ * Manifest is shown), a lone Canvas (its `partOf` Manifest, or a Manifest made around
+ * it), or annotations, an AnnotationPage or AnnotationCollection (the Manifest their first
+ * annotation's Canvas is `partOf`, at that Canvas). Everything is fetched once, with the
+ * request settings, and upgraded to Presentation 4.
+ */
+export type IIIFContent = string | Record<string, unknown>;
+export interface MapProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+	/**
+	 * Standalone: a IIIF resource (URL or object) to map: its navPlace, and its Canvases'
+	 * georeferenced images. Inside a `Root`, leave it out to map the Root's.
+	 */
+	iiifContent?: IIIFContent;
+	/** GeoJSON to draw (a FeatureCollection, Feature or geometry), as navPlace is. */
+	navPlace?: unknown;
+	/** Georeference Extension annotations to overlay, on a Canvas or an image service. */
+	georeferences?: unknown[];
+	/** Draw georeferenced images over the basemap. Default true. */
+	overlay?: boolean;
+	/** The overlays' opacity, 0 to 1. Default 0.75. */
+	overlayOpacity?: number;
+	/** A MapLibre style URL, used as it is. Default: Clover's relief basemap (OpenFreeMap). */
+	styleUrl?: string;
+	/**
+	 * Where MapLibre's worker is served from, if your bundler moves MapLibre's files (see
+	 * the Map docs). By default MapLibre finds its own.
+	 */
+	workerUrl?: string;
+	/** Zoom with the wheel or trackpad. Default false, so an embedded map never traps page scroll. */
+	scrollZoom?: boolean;
+	/**
+	 * A place was chosen, on the map or in its list. Inside a `Root`, choosing one on a
+	 * Canvas also goes there.
+	 */
+	onSelect?: (feature: MapFeature) => void;
+	/** Standalone: credentials, headers and `fetch`. */
+	request?: CloverRequest;
+	/** Standalone: the language to read IIIF text in. */
+	language?: string;
+	as?: React.ElementType;
+}
+declare const CloverMap: React.ForwardRefExoticComponent<MapProps & React.RefAttributes<HTMLElement>>;
+/** Serve MapLibre's worker from `url` for every map Clover draws (a Viewer's Map tab included). */
+export declare function setMapWorkerUrl(url: string | undefined): void;
+
+export {
+	CloverMap as Map,
+};
+
+export {};

package/dist/map/index.mjs

@@ -0,0 +1,16 @@
+"use client";
+import { CloverMap } from "../components/Map/Map.mjs";
+import { setMapWorkerUrl } from "../core/map-config.mjs";
+import { affineTransform, boundsOf, cornersOf, georeferencesOf, navPlaceOf, readGeoreference } from "../core/geo.mjs";
+import { hasMapData } from "../core/geo-detect.mjs";
+export {
+  CloverMap as Map,
+  affineTransform,
+  boundsOf,
+  cornersOf,
+  georeferencesOf,
+  hasMapData,
+  navPlaceOf,
+  readGeoreference,
+  setMapWorkerUrl
+};

package/dist/react/context.mjs

@@ -0,0 +1,46 @@
+"use client";
+import { createContext, useContext, useRef, useSyncExternalStore } from "react";
+const CloverContext = createContext(null);
+function useOptionalClover() {
+  return useContext(CloverContext);
+}
+function useClover(part = "This part") {
+  const value = useContext(CloverContext);
+  if (!value) {
+    throw new Error(`${part} must be rendered inside <Clover.Root>.`);
+  }
+  return value;
+}
+function useCloverSelector(selector, isEqual = Object.is, part) {
+  const { clover } = useClover(part);
+  const cache = useRef(null);
+  const read = () => {
+    const value = selector(clover.store.get());
+    if (cache.current && isEqual(cache.current.value, value)) {
+      return cache.current.value;
+    }
+    cache.current = { value };
+    return value;
+  };
+  return useSyncExternalStore(clover.store.subscribe, read, read);
+}
+const NO_STORE = {
+  subscribe: () => () => void 0
+};
+function useOptionalCloverSelector(selector, fallback) {
+  const context = useContext(CloverContext);
+  const store = context == null ? void 0 : context.clover.store;
+  const read = () => store ? selector(store.get()) : fallback;
+  return useSyncExternalStore(
+    store ? store.subscribe : NO_STORE.subscribe,
+    read,
+    read
+  );
+}
+export {
+  CloverContext,
+  useClover,
+  useCloverSelector,
+  useOptionalClover,
+  useOptionalCloverSelector
+};