react-cheminfo 0.22.0 → 0.24.0

package/src/projection/ui/projectionMapChrome.ts

@@ -8,13 +8,15 @@
  * honest as the controls around it change.
  */
 
-import { formatInteger } from '../../format/core/numbers.ts';
 import type { OverlayLegendEntry } from '../../overlay/ui/OverlayLegend.tsx';
 import type { EllipseSize } from '../../scatter/core/confidenceEllipse.ts';
 import { fillCopy } from '../core/fillCopy.ts';
 import type { ProjectionCopy } from '../core/projectionCopy.ts';
 import type { ProjectionMarker } from '../core/projectionResult.ts';
-import type { ResolvedProjectionGroups } from '../core/projectionSamples.ts';
+import type {
+  ResolvedProjectionGroups,
+  ResolvedProjectionShapes,
+} from '../core/projectionSamples.ts';
 
 import { ellipseCoverageText } from './projectionEllipse.ts';
 import { UNGROUPED_INK } from './projectionMapModel.ts';
@@ -27,6 +29,8 @@ interface ProjectionMapChromeInput {
   groups: ResolvedProjectionGroups;
   /** Whether colour stands for the group at all. */
   colored: boolean;
+  /** The grouping the dots are shaped by, or `null` while they are all discs. */
+  shapes: ResolvedProjectionShapes | null;
   /** How large the group outlines are, or `null` for none. */
   ellipse: EllipseSize | null;
   /** How many samples a group needs before it is outlined at all. */
@@ -82,6 +86,7 @@ export function projectionMapChrome(
   input: ProjectionMapChromeInput,
 ): ProjectionMapChrome {
   const { copy, groups, colored, ellipse, showGroupMeans, markers } = input;
+  const { shapes } = input;
   const { minimumPoints, fittedCount, total, figure = 'map' } = input;
   const entries: OverlayLegendEntry[] = [];
   const skipped: string[] = [];
@@ -108,6 +113,7 @@ export function projectionMapChrome(
       });
     }
   }
+  appendShapeEntries(entries, shapes);
   appendMarkerEntries(entries, markers, groups);
 
   const hollow = fittedCount < total;
@@ -121,7 +127,7 @@ export function projectionMapChrome(
   }
 
   return {
-    title: legendTitle(copy, groups, colored),
+    title: legendTitle(copy, groups, colored, shapes),
     entries,
     caption: captionFor(
       copy,
@@ -136,44 +142,60 @@ export function projectionMapChrome(
 }
 
 /**
- * The sentence reporting what a gesture picked out.
- * @param copy - The words the map writes.
- * @param count - How many samples are selected.
- * @param total - How many there are in all.
- * @returns The sentence.
- */
-export function projectionSelectionSentence(
-  copy: ProjectionCopy,
-  count: number,
-  total: number,
-): string {
-  if (count === 0) return copy.sentence.selectionNone;
-  return fillCopy(copy.sentence.selection, {
-    count: formatInteger(count),
-    total: formatInteger(total),
-  });
-}
-
-/**
- * The sentence over the legend.
+ * The sentence over the legend, naming what the colour and the shape stand
+ * for.
  *
- * When colour stands for nothing the entries left are all shape, so the title
- * names the shape channel: a legend naming no encoding at all is the one fault
- * this title exists to prevent, and it is not fixed by leaving the title out.
+ * When neither stands for a grouping the entries left are all marks, so the
+ * title names the shape channel: a legend naming no encoding at all is the one
+ * fault this title exists to prevent, and it is not fixed by leaving it out.
  * @param copy - The words the map writes.
  * @param groups - The groups as the map colours them.
  * @param colored - Whether colour stands for the group at all.
+ * @param shapes - The grouping the dots are shaped by, or `null`.
  * @returns The title.
  */
 function legendTitle(
   copy: ProjectionCopy,
   groups: ResolvedProjectionGroups,
   colored: boolean,
+  shapes: ResolvedProjectionShapes | null,
 ): string {
-  if (!colored || groups.entries.length === 0) return copy.legend.shapes;
-  return fillCopy(copy.legend.mapNoEllipse, {
-    groups: groups.label.toLowerCase(),
-  });
+  const parts: string[] = [];
+  if (colored && groups.entries.length > 0) {
+    parts.push(
+      fillCopy(copy.legend.mapNoEllipse, {
+        groups: groups.label.toLowerCase(),
+      }),
+    );
+  }
+  if (shapes !== null) {
+    parts.push(
+      fillCopy(copy.legend.shapedBy, { shapes: shapes.label.toLowerCase() }),
+    );
+  }
+  return parts.length === 0 ? copy.legend.shapes : parts.join(' ');
+}
+
+/**
+ * One entry per shape, drawn in the muted ink: a colour on a shape's entry
+ * would claim a group of the colour grouping it does not stand for.
+ * @param entries - The legend, appended to in place.
+ * @param shapes - The grouping the dots are shaped by, or `null`.
+ */
+function appendShapeEntries(
+  entries: OverlayLegendEntry[],
+  shapes: ResolvedProjectionShapes | null,
+): void {
+  if (shapes === null) return;
+  for (const entry of shapes.entries) {
+    entries.push({
+      id: `shape-${entry.id}`,
+      label: entry.label,
+      color: SHAPE_INK,
+      shape: entry.shape,
+      count: entry.count,
+    });
+  }
 }
 
 function captionFor(
@@ -221,3 +243,6 @@ function appendMarkerEntries(
     });
   }
 }
+
+/** The ink a shape's entry is drawn in, the one the key uses for marks that name no colour. */
+const SHAPE_INK = 'var(--text-muted)';

package/src/projection/ui/projectionMapCorner.ts

@@ -0,0 +1,67 @@
+/**
+ * Which corner of the map the floating key takes.
+ *
+ * It is a module of its own because it is the one piece of the map that has to
+ * know where the dots fall before anything is drawn over them, and it is all
+ * arithmetic that can be checked without rendering anything.
+ */
+
+import { emptiestCorner } from '../../overlay/core/emptiestCorner.ts';
+import type { OverlayCorner } from '../../overlay/core/overlayPlacement.ts';
+
+import type { ProjectionMapCloud } from './projectionMapModel.ts';
+
+/**
+ * The corner of the map with the fewest dots under it.
+ *
+ * All four are offered. The chrome that asks is laid out inside the plot
+ * rectangle rather than over the figure's box, so no corner of it costs the
+ * reader an axis label, and the only thing left to weigh is how many samples
+ * each one would cover.
+ * @param cloud - Where every sample sits, in data units.
+ * @param xDomain - The range the horizontal axis covers.
+ * @param yDomain - The range the vertical axis covers.
+ * @param width - Width of the plot rectangle, in pixels.
+ * @param height - Its height.
+ * @returns The corner the card sits in.
+ */
+export function projectionMapCorner(
+  cloud: ProjectionMapCloud,
+  xDomain: readonly [number, number],
+  yDomain: readonly [number, number],
+  width: number,
+  height: number,
+): OverlayCorner {
+  return emptiestCorner(
+    placeAlong(cloud.x, xDomain, width, false),
+    placeAlong(cloud.y, yDomain, height, true),
+    { width, height, cardWidth: CARD_WIDTH, cardHeight: CARD_HEIGHT },
+  );
+}
+
+function placeAlong(
+  values: Float64Array,
+  domain: readonly [number, number],
+  size: number,
+  flip: boolean,
+): Float64Array {
+  const span = domain[1] - domain[0];
+  const factor = span === 0 ? 0 : size / span;
+  const pixels = new Float64Array(values.length);
+  for (let index = 0; index < values.length; index++) {
+    const along = ((values[index] ?? Number.NaN) - domain[0]) * factor;
+    pixels[index] = flip ? size - along : along;
+  }
+  return pixels;
+}
+
+/**
+ * How much of the plot the floating key is expected to cover.
+ *
+ * It is an estimate on purpose — the card has not been laid out when the
+ * corner is chosen — and it is the compact key's size rather than the roomier
+ * card the overlay domain assumes: a corner counted as three species wide
+ * would call a corner busy that the key never reaches.
+ */
+const CARD_WIDTH = 170;
+const CARD_HEIGHT = 84;

package/src/projection/ui/projectionMapModel.ts

@@ -1,5 +1,5 @@
 /**
- * Where a map's samples land, and which corner of the picture is free.
+ * Where a map's samples land, and what a plot is handed to draw them.
  *
  * It sits beside the component rather than inside it because a plot has to
  * know where its dots fall before it can decide where its controls may sit,
@@ -14,15 +14,17 @@ import {
 import { chartAxisTitle } from '../../chart/core/chartLabels.ts';
 import type { ChartViewport } from '../../chart/core/chartViewport.ts';
 import type { MatrixLike } from '../../chart/core/matrix.ts';
-import { emptiestCorner } from '../../overlay/core/emptiestCorner.ts';
-import type { OverlayCorner } from '../../overlay/core/overlayPlacement.ts';
+import type { OverlaySampleShape } from '../../overlay/core/overlayMarks.ts';
 import type { ScatterGroup } from '../../scatter/ui/scatterFigureProps.ts';
 import type { ScatterMarker } from '../../scatter/ui/scatterPlotProps.ts';
 import type {
   ProjectionMarker,
   ProjectionResult,
 } from '../core/projectionResult.ts';
-import type { ResolvedProjectionGroups } from '../core/projectionSamples.ts';
+import type {
+  ResolvedProjectionGroups,
+  ResolvedProjectionShapes,
+} from '../core/projectionSamples.ts';
 
 /** Where every sample sits on the map, in the embedding's own units. */
 export interface ProjectionMapCloud {
@@ -119,34 +121,6 @@ export function projectionMapViewport(
   };
 }
 
-/**
- * The corner of the map with the fewest dots under it.
- *
- * All four are offered. The chrome that asks is laid out inside the plot
- * rectangle rather than over the figure's box, so no corner of it costs the
- * reader an axis label, and the only thing left to weigh is how many samples
- * each one would cover.
- * @param cloud - Where every sample sits, in data units.
- * @param xDomain - The range the horizontal axis covers.
- * @param yDomain - The range the vertical axis covers.
- * @param width - Width of the plot rectangle, in pixels.
- * @param height - Its height.
- * @returns The corner the card sits in.
- */
-export function projectionMapCorner(
-  cloud: ProjectionMapCloud,
-  xDomain: readonly [number, number],
-  yDomain: readonly [number, number],
-  width: number,
-  height: number,
-): OverlayCorner {
-  return emptiestCorner(
-    placeAlong(cloud.x, xDomain, width, false),
-    placeAlong(cloud.y, yDomain, height, true),
-    { width, height, cardWidth: CARD_WIDTH, cardHeight: CARD_HEIGHT },
-  );
-}
-
 /**
  * The reference points of a result, placed on the two axes the map draws.
  * @param markers - The reference points, in the embedding's own units.
@@ -192,6 +166,20 @@ export function projectionScatterGroups(
   return plotted;
 }
 
+/**
+ * The shapes in the order a plot names them by index.
+ * @param shapes - The grouping the dots are shaped by, or `null`.
+ * @returns One shape per group, or nothing while every dot is a disc.
+ */
+export function projectionScatterShapes(
+  shapes: ResolvedProjectionShapes | null,
+): OverlaySampleShape[] | undefined {
+  if (shapes === null) return undefined;
+  const list: OverlaySampleShape[] = [];
+  for (const entry of shapes.entries) list.push(entry.shape);
+  return list;
+}
+
 /**
  * What one axis of the map is called.
  *
@@ -220,32 +208,5 @@ function withRoom(
   return [extent.min, extent.max];
 }
 
-function placeAlong(
-  values: Float64Array,
-  domain: readonly [number, number],
-  size: number,
-  flip: boolean,
-): Float64Array {
-  const span = domain[1] - domain[0];
-  const factor = span === 0 ? 0 : size / span;
-  const pixels = new Float64Array(values.length);
-  for (let index = 0; index < values.length; index++) {
-    const along = ((values[index] ?? Number.NaN) - domain[0]) * factor;
-    pixels[index] = flip ? size - along : along;
-  }
-  return pixels;
-}
-
-/**
- * How much of the plot the floating key is expected to cover.
- *
- * It is an estimate on purpose — the card has not been laid out when the
- * corner is chosen — and it is the compact key's size rather than the roomier
- * card the overlay domain assumes: a corner counted as three species wide
- * would call a corner busy that the key never reaches.
- */
-const CARD_WIDTH = 170;
-const CARD_HEIGHT = 84;
-
 /** Room left around a framed selection, as a share of its own span. */
 const SELECTION_ROOM = 0.1;

package/src/projection/ui/projectionMapView.ts

@@ -18,23 +18,25 @@ import type { OrbitCamera } from '../../scatter3d/core/orbitCamera.ts';
 import { DEFAULT_ORBIT_CAMERA } from '../../scatter3d/core/orbitCamera.ts';
 import type { ProjectionCopy } from '../core/projectionCopy.ts';
 import type { ProjectionOptions } from '../core/projectionOptions.ts';
+import { NO_GROUPING } from '../core/projectionOptions.ts';
 import type {
   ProjectionMarker,
   ProjectionResult,
 } from '../core/projectionResult.ts';
-import type { ResolvedProjectionGroups } from '../core/projectionSamples.ts';
+import type {
+  ResolvedProjectionGroups,
+  ResolvedProjectionShapes,
+} from '../core/projectionSamples.ts';
 
 import type { SelectionReport } from './ProjectionMapCaption.tsx';
 import type { ProjectionMapChrome } from './projectionMapChrome.ts';
-import {
-  projectionMapChrome,
-  projectionSelectionSentence,
-} from './projectionMapChrome.ts';
+import { projectionMapChrome } from './projectionMapChrome.ts';
 import {
   MINIMUM_OUTLINE_POINTS,
   projectionMapDomain,
   projectionMapViewport,
 } from './projectionMapModel.ts';
+import { projectionSelectionSentence } from './projectionSelectionSentence.ts';
 import { MINIMUM_SHELL_POINTS } from './projectionSpaceModel.ts';
 
 /** What {@link useProjectionMapView} needs. */
@@ -45,6 +47,8 @@ interface ProjectionMapViewInput {
   copy: ProjectionCopy;
   /** The groups as every figure of this viewer draws them. */
   groups: ResolvedProjectionGroups;
+  /** The grouping the dots are shaped by, or `null` while they are all discs. */
+  shapes: ResolvedProjectionShapes | null;
   /** Every option, already made safe against the result. */
   options: ProjectionOptions;
   /** The selected rows, as indices into the score matrix. */
@@ -93,7 +97,7 @@ export interface ProjectionMapView {
 export function useProjectionMapView(
   input: ProjectionMapViewInput,
 ): ProjectionMapView {
-  const { result, copy, groups, options, selected, onSettle } = input;
+  const { result, copy, groups, shapes, options, selected, onSettle } = input;
   const { scores, fittedCount, markers } = result;
   const { colorBy, ellipse, showGroupMeans, xAxis, yAxis } = options;
 
@@ -139,13 +143,14 @@ export function useProjectionMapView(
     setCloudZoom(1);
   }, []);
 
-  const colored = colorBy === 'group' && groups.entries.length > 0;
+  const colored = colorBy !== NO_GROUPING && groups.entries.length > 0;
   const chrome = useMemo(
     () =>
       projectionMapChrome({
         copy,
         groups,
         colored,
+        shapes,
         ellipse: colored ? ellipse : null,
         minimumPoints: MINIMUM_OUTLINE_POINTS,
         showGroupMeans,
@@ -157,6 +162,7 @@ export function useProjectionMapView(
       copy,
       groups,
       colored,
+      shapes,
       ellipse,
       showGroupMeans,
       markers,
@@ -171,6 +177,7 @@ export function useProjectionMapView(
         copy,
         groups,
         colored,
+        shapes,
         ellipse: colored ? ellipse : null,
         minimumPoints: MINIMUM_SHELL_POINTS,
         showGroupMeans: false,
@@ -179,7 +186,7 @@ export function useProjectionMapView(
         total: scores.rows,
         figure: 'space',
       }),
-    [copy, groups, colored, ellipse, fittedCount, scores],
+    [copy, groups, colored, shapes, ellipse, fittedCount, scores],
   );
 
   const settle = useCallback(

package/src/projection/ui/projectionSelectionSentence.ts

@@ -0,0 +1,22 @@
+import { formatInteger } from '../../format/core/numbers.ts';
+import { fillCopy } from '../core/fillCopy.ts';
+import type { ProjectionCopy } from '../core/projectionCopy.ts';
+
+/**
+ * The sentence reporting what a gesture picked out.
+ * @param copy - The words the map writes.
+ * @param count - How many samples are selected.
+ * @param total - How many there are in all.
+ * @returns The sentence.
+ */
+export function projectionSelectionSentence(
+  copy: ProjectionCopy,
+  count: number,
+  total: number,
+): string {
+  if (count === 0) return copy.sentence.selectionNone;
+  return fillCopy(copy.sentence.selection, {
+    count: formatInteger(count),
+    total: formatInteger(total),
+  });
+}

package/src/projection/ui/projectionStateApi.ts

@@ -0,0 +1,57 @@
+/**
+ * What the one hook every tab shares hands out.
+ *
+ * The type lives beside the hook rather than inside it because the hook is
+ * short and its answer is not: a reader looking for how the state is kept
+ * should not have to scroll past a page of documented fields to find it.
+ */
+
+import type { ScatterSelectionMode } from '../../scatter/core/scatterSelection.ts';
+import type { SelectionChange } from '../../scatter/ui/useScatterSelection.ts';
+import type { ProjectionOptions } from '../core/projectionOptions.ts';
+import type {
+  ProjectionGrouping,
+  ResolvedProjectionGroups,
+  ResolvedProjectionShapes,
+} from '../core/projectionSamples.ts';
+import type { ProjectionTab } from '../core/projectionTabs.ts';
+
+import type { ProjectionSelection } from './projectionSelection.ts';
+
+/** What every tab reads, and the five ways any of them changes it. */
+export interface ProjectionStateApi {
+  /** The tabs this result can fill, in reading order. */
+  tabs: readonly ProjectionTab[];
+  /** The one showing. */
+  tab: ProjectionTab;
+  /** Move to another tab. One the result cannot fill is ignored. */
+  setTab: (tab: ProjectionTab) => void;
+  /**
+   * The grouping the dots are coloured by, resolved once per change; empty
+   * while the colour stands for nothing.
+   */
+  groups: ResolvedProjectionGroups;
+  /**
+   * The grouping the dots are shaped by, resolved once per change, or `null`
+   * while they are all discs.
+   */
+  shapes: ResolvedProjectionShapes | null;
+  /** Every grouping the samples carry, for the pickers that choose between them. */
+  groupings: readonly ProjectionGrouping[];
+  /** Every option, already made safe against the result. */
+  options: ProjectionOptions;
+  /** Change some of them; the rest are carried over and checked again. */
+  setOptions: (patch: Partial<ProjectionOptions>) => void;
+  /** The selected rows, as indices, which is what a plot draws. */
+  selected: readonly number[];
+  /** Settle a selection a plot's own gesture produced. */
+  settleSelection: (change: SelectionChange) => void;
+  /** Settle one from elsewhere — a legend entry, a table beside the figure. */
+  selectRows: (
+    rows: readonly number[],
+    mode: ScatterSelectionMode,
+    source: ProjectionSelection['source'],
+  ) => void;
+  /** Draw one pair of axes on the map, which is what a cell of the grid does. */
+  selectPair: (xAxis: number, yAxis: number) => void;
+}

package/src/projection/ui/projectionTabModels.ts

@@ -90,7 +90,7 @@ export function useProjectionModels(
   return {
     profiles,
     shares,
-    sampleName: samples.ids[one] ?? `Row ${one + 1}`,
+    sampleName: samples.labels?.[one] ?? samples.ids[one] ?? `Row ${one + 1}`,
   };
 }
 

package/src/projection/ui/useProjectionState.ts

@@ -2,9 +2,13 @@ import { useCallback, useMemo, useState } from 'react';
 
 import type { ScatterSelectionMode } from '../../scatter/core/scatterSelection.ts';
 import type { SelectionChange } from '../../scatter/ui/useScatterSelection.ts';
+import {
+  projectionGrouping,
+  resolveProjectionGroups,
+  resolveProjectionShapes,
+} from '../core/projectionGroupings.ts';
 import type { ProjectionOptions } from '../core/projectionOptions.ts';
-import type { ResolvedProjectionGroups } from '../core/projectionSamples.ts';
-import { resolveProjectionGroups } from '../core/projectionSamples.ts';
+import type { ProjectionGrouping } from '../core/projectionSamples.ts';
 import type { ProjectionTab } from '../core/projectionTabs.ts';
 import { projectionTabs } from '../core/projectionTabs.ts';
 import { resolveProjectionOptions } from '../core/resolveProjectionOptions.ts';
@@ -15,6 +19,7 @@ import {
   projectionNamesOf,
   projectionRowsOf,
 } from './projectionSelection.ts';
+import type { ProjectionStateApi } from './projectionStateApi.ts';
 import type { ProjectionViewerProps } from './projectionViewerProps.ts';
 
 /**
@@ -41,34 +46,6 @@ type ProjectionStateOptions = Pick<
   | 'onOptionsChange'
 >;
 
-/** What every tab reads, and the five ways any of them changes it. */
-export interface ProjectionStateApi {
-  /** The tabs this result can fill, in reading order. */
-  tabs: readonly ProjectionTab[];
-  /** The one showing. */
-  tab: ProjectionTab;
-  /** Move to another tab. One the result cannot fill is ignored. */
-  setTab: (tab: ProjectionTab) => void;
-  /** The groups as every figure draws them, resolved once per change. */
-  groups: ResolvedProjectionGroups;
-  /** Every option, already made safe against the result. */
-  options: ProjectionOptions;
-  /** Change some of them; the rest are carried over and checked again. */
-  setOptions: (patch: Partial<ProjectionOptions>) => void;
-  /** The selected rows, as indices, which is what a plot draws. */
-  selected: readonly number[];
-  /** Settle a selection a plot's own gesture produced. */
-  settleSelection: (change: SelectionChange) => void;
-  /** Settle one from elsewhere — a legend entry, a table beside the figure. */
-  selectRows: (
-    rows: readonly number[],
-    mode: ScatterSelectionMode,
-    source: ProjectionSelection['source'],
-  ) => void;
-  /** Draw one pair of axes on the map, which is what a cell of the grid does. */
-  selectPair: (xAxis: number, yAxis: number) => void;
-}
-
 /**
  * The tab, the pair of axes, the selection and the options, controlled or not.
  *
@@ -121,13 +98,23 @@ export function useProjectionState(
     () => defaultOptions ?? {},
   );
 
+  const groupings = samples.groupings ?? NO_GROUPINGS;
+  const settled = useMemo(
+    () =>
+      resolveProjectionOptions(heldOptions ?? ownOptions, result, groupings),
+    [groupings, heldOptions, ownOptions, result],
+  );
+  const { colorBy, shapeBy } = settled;
+  const rowCount = result.scores.rows;
   const groups = useMemo(
-    () => resolveProjectionGroups(samples, result.scores.rows),
-    [result, samples],
+    () =>
+      resolveProjectionGroups(projectionGrouping(samples, colorBy), rowCount),
+    [colorBy, rowCount, samples],
   );
-  const settled = useMemo(
-    () => resolveProjectionOptions(heldOptions ?? ownOptions, result),
-    [heldOptions, ownOptions, result],
+  const shapes = useMemo(
+    () =>
+      resolveProjectionShapes(projectionGrouping(samples, shapeBy), rowCount),
+    [rowCount, samples, shapeBy],
   );
 
   const setTab = useCallback(
@@ -142,11 +129,15 @@ export function useProjectionState(
 
   const setOptions = useCallback(
     (patch: Partial<ProjectionOptions>) => {
-      const next = resolveProjectionOptions({ ...settled, ...patch }, result);
+      const next = resolveProjectionOptions(
+        { ...settled, ...patch },
+        result,
+        groupings,
+      );
       if (heldOptions === undefined) setOwnOptions(next);
       onOptionsChange?.(next);
     },
-    [heldOptions, onOptionsChange, result, settled],
+    [groupings, heldOptions, onOptionsChange, result, settled],
   );
 
   const selectRows = useCallback(
@@ -189,6 +180,8 @@ export function useProjectionState(
     tab: inReach(tab, tabs) ?? inReach(ownTab, tabs) ?? tabs[0] ?? 'map',
     setTab,
     groups,
+    shapes,
+    groupings,
     options: settled,
     setOptions,
     selected:
@@ -222,3 +215,6 @@ function inReach(
   }
   return undefined;
 }
+
+/** No groupings at all, shared so an absent list keeps one identity. */
+const NO_GROUPINGS: readonly ProjectionGrouping[] = [];

package/src/scatter/core/index.ts

@@ -38,6 +38,7 @@ export {
   resetLassoPath,
 } from './lassoPath.ts';
 export { pointInPolygon, pointsInPolygon, polygonBounds } from './polygon.ts';
+export { pointShapePath } from './pointShape.ts';
 export type { ScatterGroupMoments } from './scatterGroupMoments.ts';
 export type {
   ScatterGroupSpread,