react-cheminfo 0.11.0 → 0.12.0

package/src/scatter3d/ui/cloudZoom.ts

@@ -1,3 +1,5 @@
+import { clamp } from '../../format/core/clamp.ts';
+
 /**
  * How far the reader may stand back from the box, and how near they may get.
  *
@@ -17,6 +19,5 @@ export const CLOUD_ZOOM_RANGE = { min: 0.4, max: 4 } as const;
  * @returns The zoom to draw at; `1` for anything that is not a number.
  */
 export function clampCloudZoom(zoom: number): number {
-  if (!Number.isFinite(zoom)) return 1;
-  return Math.min(CLOUD_ZOOM_RANGE.max, Math.max(CLOUD_ZOOM_RANGE.min, zoom));
+  return clamp(zoom, CLOUD_ZOOM_RANGE.min, CLOUD_ZOOM_RANGE.max, 1);
 }

package/src/scatter3d/ui/index.ts

@@ -12,8 +12,6 @@
 
 export type { CloudFrameLayerProps } from './CloudFrameLayer.tsx';
 export { CloudFrameLayer } from './CloudFrameLayer.tsx';
-export type { CloudPointLayerProps } from './CloudPointLayer.tsx';
-export { CloudPointLayer } from './CloudPointLayer.tsx';
 export type { CloudShell, CloudShellLayerProps } from './CloudShellLayer.tsx';
 export { CloudShellLayer } from './CloudShellLayer.tsx';
 export type {
@@ -35,7 +33,7 @@ export { SHELL_FILL_OPACITY, shellGlassStops } from './cloudShellStyles.ts';
 export { CLOUD_ZOOM_RANGE, clampCloudZoom } from './cloudZoom.ts';
 export type { CloudShellsInput } from './scatterCloudModel.ts';
 export { cloudLabel, cloudShells } from './scatterCloudModel.ts';
-export type { CloudGesture, ScatterCloudProps } from './scatterCloudProps.ts';
+export type { ScatterCloudProps } from './scatterCloudProps.ts';
 export { ScatterCloud } from './ScatterCloud.tsx';
 export type { OrbitDrag, OrbitDragOptions } from './useOrbitDrag.ts';
 export { useOrbitDrag } from './useOrbitDrag.ts';

package/src/scatter3d/ui/orbitDragTrack.ts

@@ -0,0 +1,133 @@
+/**
+ * What a drag over a cloud has done so far.
+ *
+ * Kept out of `useOrbitDrag` the way `lassoGesture` is kept out of the lasso:
+ * how far the pointer has travelled, which turn is waiting for the next frame
+ * and whether a release was a tap are questions with one answer each, and none
+ * of them needs React to be read or checked.
+ */
+
+/**
+ * How far a press may travel and still be a tap, in pixels of total travel.
+ *
+ * Generous on purpose: a mouse moves a pixel or two under the click of its own
+ * button, and a finger moves rather more, so a stricter number turns "pick
+ * this sample" into "turn the box by nothing at all" for anybody whose hand is
+ * not steady.
+ */
+export const ORBIT_TAP_SLACK = 5;
+
+/** What the pointer has done since the last frame, waiting for the next. */
+export interface PendingTurn {
+  /** Where it is, for a move that is not turning anything. */
+  x: number;
+  /** Where it is. */
+  y: number;
+  /** How far it has moved across since the last frame. */
+  dx: number;
+  /** How far it has moved down. */
+  dy: number;
+}
+
+/** A drag followed from its press: where the pointer was, and how far it went. */
+export interface OrbitDragTrack {
+  /** Where the pointer was on the last event, in window pixels. */
+  lastX: number;
+  /** Where it was vertically. */
+  lastY: number;
+  /** How far it has travelled since the press: every move's `|dx| + |dy|`. */
+  travel: number;
+  /** What waits for the next frame, or `null` when nothing does. */
+  pending: PendingTurn | null;
+}
+
+/**
+ * A track with no press behind it.
+ * @returns The track, to be held for the life of the surface.
+ */
+export function createOrbitDragTrack(): OrbitDragTrack {
+  return { lastX: 0, lastY: 0, travel: 0, pending: null };
+}
+
+/**
+ * Start following a press.
+ * @param track - The track, changed in place.
+ * @param clientX - Where the press happened, in the window.
+ * @param clientY - Where it happened vertically.
+ */
+export function pressOrbitDrag(
+  track: OrbitDragTrack,
+  clientX: number,
+  clientY: number,
+): void {
+  track.lastX = clientX;
+  track.lastY = clientY;
+  track.travel = 0;
+}
+
+/**
+ * Remember where a pointer that turns nothing has moved to.
+ * @param track - The track, changed in place.
+ * @param x - Where the pointer is on the surface.
+ * @param y - Where it is vertically.
+ */
+export function hoverOrbitDrag(
+  track: OrbitDragTrack,
+  x: number,
+  y: number,
+): void {
+  track.pending = { x, y, dx: 0, dy: 0 };
+}
+
+/**
+ * Follow a move of the claimed pointer.
+ *
+ * The travel is counted whether or not the drag may turn the box, so a press
+ * that wandered is still not a tap when turning is off.
+ * @param track - The track, changed in place.
+ * @param clientX - Where the pointer is now, in the window.
+ * @param clientY - Where it is vertically.
+ * @param enabled - Whether the drag turns the box at all.
+ * @returns Whether a frame has to be booked for the turn now waiting.
+ */
+export function followOrbitDrag(
+  track: OrbitDragTrack,
+  clientX: number,
+  clientY: number,
+  enabled: boolean,
+): boolean {
+  const dx = clientX - track.lastX;
+  const dy = clientY - track.lastY;
+  track.lastX = clientX;
+  track.lastY = clientY;
+  track.travel += Math.abs(dx) + Math.abs(dy);
+  if (!enabled) return false;
+  const waiting = track.pending;
+  track.pending = {
+    x: 0,
+    y: 0,
+    dx: (waiting?.dx ?? 0) + dx,
+    dy: (waiting?.dy ?? 0) + dy,
+  };
+  return true;
+}
+
+/**
+ * Take what was waiting for the frame, leaving nothing behind.
+ * @param track - The track, changed in place.
+ * @returns The waiting turn or move, or `null` when there was none.
+ */
+export function takePendingTurn(track: OrbitDragTrack): PendingTurn | null {
+  const next = track.pending;
+  track.pending = null;
+  return next;
+}
+
+/**
+ * Whether the press being released went nowhere worth calling a turn.
+ * @param track - The track.
+ * @returns `true` when the travel is within {@link ORBIT_TAP_SLACK}.
+ */
+export function isOrbitTap(track: OrbitDragTrack): boolean {
+  return track.travel <= ORBIT_TAP_SLACK;
+}

package/src/scatter3d/ui/scatterCloudModel.ts

@@ -3,13 +3,14 @@
  * group, and the sentence a screen reader is given instead of the picture.
  *
  * It is kept out of the component for the same reason the flat scatter's model
- * is — a shell has to be cut before there is anything to project, and cutting
- * it inside the render callback would cut it again on every turn.
+ * is: a shell is fitted once per change of data, and fitting it inside the
+ * render callback would fit it again on every frame of a turn.
  */
 
+import { chartGroupIndex } from '../../chart/core/chartGroups.ts';
 import type { EllipseSize } from '../../scatter/core/confidenceEllipse.ts';
+import type { ScatterGroup } from '../../scatter/ui/scatterFigureProps.ts';
 import type { ScatterGroupInk } from '../../scatter/ui/scatterPlotModel.ts';
-import type { ScatterGroup } from '../../scatter/ui/scatterPlotProps.ts';
 import { confidenceEllipsoid } from '../core/confidenceEllipsoid.ts';
 import type { Vector3 } from '../core/orbitCamera.ts';
 
@@ -54,8 +55,8 @@ export function cloudShells(input: CloudShellsInput): CloudShell[] {
   const held: Vector3[][] = groups.map(() => []);
   const count = Math.min(cube.length, groupOf.length);
   for (let index = 0; index < count; index++) {
-    const group = groupOf[index];
-    if (group === undefined || group < 0 || group >= groups.length) continue;
+    const group = chartGroupIndex(groupOf, index, groups.length);
+    if (group === -1) continue;
     (held[group] as Vector3[]).push(cube[index] as Vector3);
   }
 

package/src/scatter3d/ui/scatterCloudProps.ts

@@ -1,27 +1,22 @@
 /**
  * What a caller hands a `ScatterCloud`.
  *
- * The types live beside the component rather than inside it because the
- * component's own file would otherwise be mostly prose, exactly as the flat
- * scatter's are.
+ * What the cloud shares with the flat map — groups, labels, selection, hover
+ * and double click — is declared once in `scatterFigureProps.ts`; this adds
+ * the three axes, the shells, and the camera only a box has.
  */
 
-import type { ReactNode } from 'react';
-
 import type { EllipseSize } from '../../scatter/core/confidenceEllipse.ts';
-import type { ScatterSelectionMode } from '../../scatter/core/scatterSelection.ts';
 import type {
-  ScatterGroup,
-  ScatterPointOpen,
-} from '../../scatter/ui/scatterPlotProps.ts';
-import type { SelectionChange } from '../../scatter/ui/useScatterSelection.ts';
+  ScatterGroupProps,
+  ScatterInteractionProps,
+} from '../../scatter/ui/scatterFigureProps.ts';
 import type { CloudGesture } from '../core/cloudGesture.ts';
 import type { OrbitCamera } from '../core/orbitCamera.ts';
 
-export type { CloudGesture } from '../core/cloudGesture.ts';
-
 /** What a `ScatterCloud` needs. */
-export interface ScatterCloudProps {
+export interface ScatterCloudProps
+  extends ScatterGroupProps, ScatterInteractionProps {
   /** Where every sample sits along the axis that runs left to right, in data units. */
   x: ArrayLike<number>;
   /** Along the axis that runs bottom to top, in the same order. */
@@ -38,23 +33,6 @@ export interface ScatterCloudProps {
   yLabel: string;
   /** What the axis running away from the reader is called. */
   zLabel: string;
-  /**
-   * Which group each sample belongs to, as an index into `groups`. A sample
-   * with `-1`, or an index outside the range, is drawn in the muted ink and
-   * left out of every shell.
-   * @default undefined — every sample is one crowd
-   */
-  groupOf?: ArrayLike<number>;
-  /**
-   * The groups, in the order they are coloured and listed.
-   * @default undefined
-   */
-  groups?: readonly ScatterGroup[];
-  /**
-   * Which groups are drawn faint, by id — what a legend entry switches.
-   * @default undefined — every group is drawn in full
-   */
-  mutedGroups?: ReadonlySet<string>;
   /**
    * How large the group shells are, or `null` for none. A share is read in
    * three dimensions here, so the same share gives a wider shell than the same
@@ -70,35 +48,10 @@ export interface ScatterCloudProps {
    */
   ellipsoidMinimumPoints?: number;
   /**
-   * How solid the glass is; `0` draws no shells at all.
-   * @default SHELL_FILL_OPACITY
+   * How solid one wall of the glass is; `0` draws no shells at all.
+   * @default 0.1
    */
   ellipsoidFillOpacity?: number;
-  /**
-   * Whether each group's name is written once, over the middle of its own
-   * shell. It needs `groups`, since it is their names it writes.
-   * @default false
-   */
-  showGroupLabels?: boolean;
-  /**
-   * What each sample is called, written beside its own dot. A sample whose
-   * entry is `undefined` is left unnamed.
-   * @default undefined — no sample is named
-   */
-  pointLabels?: ReadonlyArray<string | undefined>;
-  /**
-   * Radius of a dot at the middle of the box, in pixels. One at the front is
-   * drawn larger and one at the back smaller, about this.
-   * @default 3.5
-   */
-  pointRadius?: number;
-  /**
-   * The index from which samples are drawn as outlines rather than filled,
-   * which is how one the model was fitted on is told from one placed into it
-   * afterwards.
-   * @default undefined — every sample is filled
-   */
-  outlinedFrom?: number;
   /**
    * What a drag does. The cloud never changes it on its own, because the
    * control belongs in the bar above the figure rather than on top of the
@@ -135,57 +88,4 @@ export interface ScatterCloudProps {
    * @default true
    */
   wheelZoom?: boolean;
-  /**
-   * The selected rows. Present, the caller owns the selection.
-   * @default undefined — the cloud keeps its own
-   */
-  selected?: readonly number[];
-  /**
-   * The rows selected before the reader touches anything.
-   * @default undefined
-   */
-  defaultSelected?: readonly number[];
-  /**
-   * Called when a lasso is released or a dot is tapped — never while a lasso
-   * is being drawn, and never while the box is being turned.
-   * @default undefined
-   */
-  onSelectionChange?: (change: SelectionChange) => void;
-  /**
-   * What a gesture with no modifier held does to the selection. Shift always
-   * adds and Alt always removes, exactly as on the map.
-   * @default 'replace'
-   */
-  selectMode?: ScatterSelectionMode;
-  /**
-   * Called with the row under the pointer, or `-1`.
-   * @default undefined
-   */
-  onHoverChange?: (index: number) => void;
-  /**
-   * Called when the reader double-clicks a sample, exactly as on the flat map:
-   * the gesture for "tell me more about this one", or "let me change it".
-   *
-   * It fires whichever gesture a drag is set to, because a double click is not
-   * a drag — a reader turning the box must not have to switch to Select to
-   * open a sample. The sample is selected first, since a double click is also
-   * two clicks; the map says why, and the two behave alike on purpose.
-   * @default undefined
-   */
-  onPointDoubleClick?: (point: ScatterPointOpen) => void;
-  /**
-   * What floats over the figure — a bar, a key, a caption, a card.
-   * @default undefined
-   */
-  overlay?: ReactNode;
-  /**
-   * What a screen reader is told the figure shows.
-   * @default a sentence built from the three axis names and the sample count
-   */
-  label?: string;
-  /**
-   * Value of the `data-testid` attribute of the wrapper.
-   * @default undefined
-   */
-  testId?: string;
 }

package/src/scatter3d/ui/useOrbitDrag.ts

@@ -1,18 +1,26 @@
 import type { PointerEvent as ReactPointerEvent } from 'react';
-import { useCallback, useMemo, useRef, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 
 import type { ScatterSelectionMode } from '../../scatter/core/scatterSelection.ts';
 import type { ScatterSurfaceProps } from '../../scatter/ui/lassoGesture.ts';
 import {
-  capturePointer,
-  dropFrame,
   modifierMode,
-  scheduleFrame,
   surfacePosition,
 } from '../../scatter/ui/lassoGesture.ts';
+import { useCapturedPointer } from '../../scatter/ui/useCapturedPointer.ts';
 import type { OrbitCamera } from '../core/orbitCamera.ts';
 import { orbitByDrag } from '../core/orbitCamera.ts';
 
+import type { OrbitDragTrack } from './orbitDragTrack.ts';
+import {
+  createOrbitDragTrack,
+  followOrbitDrag,
+  hoverOrbitDrag,
+  isOrbitTap,
+  pressOrbitDrag,
+  takePendingTurn,
+} from './orbitDragTrack.ts';
+
 /** What {@link useOrbitDrag} needs. */
 export interface OrbitDragOptions {
   /**
@@ -58,15 +66,15 @@ export interface OrbitDrag {
 /**
  * Turning the box with the pointer.
  *
- * It is the lasso's twin and is built the same way — the pointer is captured
- * on the way down so a drag that wanders off the figure keeps turning it, all
- * three ways a capture can end lead to one function, and moves are coalesced
- * to one a frame because a pointer emits many per frame and each one that
- * reaches the caller repaints every dot and every face.
+ * It is the lasso's twin and stands on the same `useCapturedPointer`, so a
+ * drag that wanders off the figure keeps turning it and every way a capture
+ * can end leads to one place. A finger is always claimed: a box whose one
+ * gesture is turning cannot be turned on a phone that scrolls instead.
  *
  * A press that goes nowhere is a tap rather than a turn of no degrees, because
  * nobody presses a mouse button without moving it a pixel or two and a reader
  * who meant to pick a sample must not have to hold their hand still to do it.
+ * The arithmetic of that decision is in `orbitDragTrack`.
  * @param options - See {@link OrbitDragOptions}.
  * @returns The drag. See {@link OrbitDrag}.
  */
@@ -80,141 +88,71 @@ export function useOrbitDrag(options: OrbitDragOptions): OrbitDrag {
     mode: restingMode = 'replace',
   } = options;
 
-  const pointerRef = useRef<number | null>(null);
-  const lastRef = useRef({ x: 0, y: 0 });
-  const travelRef = useRef(0);
-  const frameRef = useRef<number | null>(null);
-  const pendingRef = useRef<PendingTurn | null>(null);
+  const trackRef = useRef<OrbitDragTrack>(createOrbitDragTrack());
   const [turning, setTurning] = useState(false);
 
-  const flush = useCallback(() => {
-    frameRef.current = null;
-    const next = pendingRef.current;
-    pendingRef.current = null;
-    if (next === null) return;
-    if (pointerRef.current === null) {
-      onMove?.(next.x, next.y);
-      return;
-    }
-    onOrbit((camera) => orbitByDrag(camera, next.dx, next.dy));
-  }, [onMove, onOrbit]);
-
-  const end = useCallback(
-    (event: ReactPointerEvent<Element>, commit: boolean) => {
-      if (event.pointerId !== pointerRef.current) return;
-      pointerRef.current = null;
-      pendingRef.current = null;
-      dropFrame(frameRef);
-      setTurning(false);
-      if (!commit || travelRef.current > TAP_SLACK) return;
-      const at = surfacePosition(event, 0, 0);
-      onTap?.(at.x, at.y, modifierMode(event, restingMode));
-    },
-    [onTap, restingMode],
-  );
-
-  const handleDown = useCallback((event: ReactPointerEvent<Element>) => {
-    if (pointerRef.current !== null || event.button > 0) return;
-    pointerRef.current = event.pointerId;
-    lastRef.current = { x: event.clientX, y: event.clientY };
-    travelRef.current = 0;
+  const press = useCallback((event: ReactPointerEvent<Element>) => {
+    pressOrbitDrag(trackRef.current, event.clientX, event.clientY);
     setTurning(true);
-    capturePointer(event);
+    return true;
   }, []);
 
-  const handleMove = useCallback(
-    (event: ReactPointerEvent<Element>) => {
-      const active = pointerRef.current;
-      if (active === null) {
+  const follow = useCallback(
+    (event: ReactPointerEvent<Element>, claimed: boolean) => {
+      if (!claimed) {
         const at = surfacePosition(event, 0, 0);
-        pendingRef.current = { x: at.x, y: at.y, dx: 0, dy: 0 };
-        scheduleFrame(frameRef, flush);
-        return;
+        hoverOrbitDrag(trackRef.current, at.x, at.y);
+        return true;
       }
-      if (event.pointerId !== active) return;
-      const last = lastRef.current;
-      const dx = event.clientX - last.x;
-      const dy = event.clientY - last.y;
-      lastRef.current = { x: event.clientX, y: event.clientY };
-      travelRef.current += Math.abs(dx) + Math.abs(dy);
-      if (!enabled) return;
-      const waiting = pendingRef.current;
-      pendingRef.current = {
-        x: 0,
-        y: 0,
-        dx: (waiting?.dx ?? 0) + dx,
-        dy: (waiting?.dy ?? 0) + dy,
-      };
-      scheduleFrame(frameRef, flush);
+      return followOrbitDrag(
+        trackRef.current,
+        event.clientX,
+        event.clientY,
+        enabled,
+      );
     },
-    [enabled, flush],
+    [enabled],
   );
 
-  const handleUp = useCallback(
-    (event: ReactPointerEvent<Element>) => {
-      end(event, true);
+  const flush = useCallback(
+    (claimed: boolean) => {
+      const next = takePendingTurn(trackRef.current);
+      if (next === null) return;
+      if (!claimed) {
+        onMove?.(next.x, next.y);
+        return;
+      }
+      onOrbit((camera) => orbitByDrag(camera, next.dx, next.dy));
     },
-    [end],
+    [onMove, onOrbit],
   );
 
-  const handleAbandon = useCallback(
-    (event: ReactPointerEvent<Element>) => {
-      end(event, false);
+  const finish = useCallback(
+    (event: ReactPointerEvent<Element> | null, commit: boolean) => {
+      const track = trackRef.current;
+      takePendingTurn(track);
+      setTurning(false);
+      if (event === null || !commit || !isOrbitTap(track)) return;
+      const at = surfacePosition(event, 0, 0);
+      onTap?.(at.x, at.y, modifierMode(event, restingMode));
     },
-    [end],
+    [onTap, restingMode],
   );
 
-  const handleLeave = useCallback(() => {
-    if (pointerRef.current !== null) return;
-    pendingRef.current = null;
+  const forget = useCallback(() => {
+    takePendingTurn(trackRef.current);
     onLeave?.();
   }, [onLeave]);
 
-  const surface = useMemo<ScatterSurfaceProps>(
-    () => ({
-      onPointerDown: handleDown,
-      onPointerMove: handleMove,
-      onPointerUp: handleUp,
-      onPointerCancel: handleAbandon,
-      onLostPointerCapture: handleAbandon,
-      onPointerLeave: handleLeave,
-      style: {
-        cursor: enabled ? (turning ? 'grabbing' : 'grab') : 'default',
-        touchAction: 'none',
-      },
-    }),
-    [
-      enabled,
-      handleAbandon,
-      handleDown,
-      handleLeave,
-      handleMove,
-      handleUp,
-      turning,
-    ],
-  );
+  const { surface } = useCapturedPointer({
+    touch: true,
+    cursor: enabled ? (turning ? 'grabbing' : 'grab') : 'default',
+    onPress: press,
+    onMove: follow,
+    onFrame: flush,
+    onRelease: finish,
+    onLeave: forget,
+  });
 
   return { turning, surface };
 }
-
-/**
- * How far a press may travel and still be a tap, in pixels of total travel.
- *
- * Generous on purpose: a mouse moves a pixel or two under the click of its own
- * button, and a finger moves rather more, so a stricter number turns "pick
- * this sample" into "turn the box by nothing at all" for anybody whose hand is
- * not steady.
- */
-const TAP_SLACK = 5;
-
-/** What the pointer has done since the last frame, waiting for the next. */
-interface PendingTurn {
-  /** Where it is, for a move that is not turning anything. */
-  x: number;
-  /** Where it is. */
-  y: number;
-  /** How far it has moved across since the last frame. */
-  dx: number;
-  /** How far it has moved down. */
-  dy: number;
-}

package/src/seo/core/documentMeta.ts

@@ -1,3 +1,5 @@
+import { withoutQueryOrFragment } from '../../router/core/address.ts';
+
 /**
  * Keep the head in step with the page on screen after an in-app move.
  *
@@ -35,7 +37,7 @@ export function documentTitle(title: string): void {
  */
 export function canonicalLink(href: string): void {
   if (typeof document === 'undefined') return;
-  const address = withoutQuery(href);
+  const address = withoutQueryOrFragment(href);
   if (address === '') return;
 
   const existing = document.querySelector<HTMLLinkElement>(
@@ -85,8 +87,3 @@ function metaDescription(content: string): void {
   document.head.append(meta);
   meta.content = content;
 }
-
-function withoutQuery(href: string): string {
-  const cut = href.search(/[?#]/);
-  return cut === -1 ? href : href.slice(0, cut);
-}

package/src/seo/core/index.ts

@@ -1,9 +1,5 @@
 export type { DocumentMeta } from './documentMeta.ts';
-export {
-  canonicalLink,
-  documentTitle,
-  writeDocumentMeta,
-} from './documentMeta.ts';
+export { writeDocumentMeta } from './documentMeta.ts';
 export type {
   NoscriptEcosystem,
   NoscriptHrefs,
@@ -14,16 +10,12 @@ export type {
 export { noscriptIndex } from './noscript.ts';
 export type { PageMetaOptions } from './pageMeta.ts';
 export { injectPageMeta, pageDocumentMeta, pageHeadTags } from './pageMeta.ts';
+export type { PlainDescriptionOptions } from './plainDescription.ts';
+export { plainDescription, plainProse } from './plainDescription.ts';
 export type { RobotsDisallow } from './robots.ts';
 export { robotsTxt } from './robots.ts';
 export type { RouteMeta } from './routes.ts';
-export {
-  assertRoutes,
-  homeRoute,
-  pageMetaFor,
-  routeFor,
-  trimTrailingSlash,
-} from './routes.ts';
+export { assertRoutes, homeRoute, pageMetaFor, routeFor } from './routes.ts';
 export type { SiteFilesOptions } from './siteFiles.ts';
 export { sitemapXml } from './siteFiles.ts';
 export type { StartDocumentMetaOptions } from './startDocumentMeta.ts';
@@ -31,3 +23,4 @@ export { startDocumentMeta } from './startDocumentMeta.ts';
 export type { StructuredDataOptions } from './structuredData.ts';
 export { structuredDataScript } from './structuredData.ts';
 export { PAGE_BODY_MARKER, PAGE_HEAD_MARKER, fill } from './template.ts';
+export { injectTrackingScript } from './trackingScript.ts';

package/src/seo/core/noscript.ts

@@ -189,7 +189,9 @@ ${items.join('\n')}
   </ul>`;
 }
 
-function familySites(sites: readonly SiteId[] | undefined): EcosystemSite[] {
-  if (sites === undefined) return [...ECOSYSTEM_SITES];
+function familySites(
+  sites: readonly SiteId[] | undefined,
+): readonly EcosystemSite[] {
+  if (sites === undefined) return ECOSYSTEM_SITES;
   return sites.map((id) => siteById(id));
 }