@lilt-ui/charts 0.12.1 → 0.13.0

package/dist/cards/link-readings.d.ts

@@ -0,0 +1,26 @@
+export declare function linkReadings<Row>(data: readonly Row[], source: string, target: string, value: string): {
+    names: string[];
+    links: {
+        id: string;
+        source: string;
+        target: string;
+        value: number | null;
+        datum: Row;
+    }[];
+    error: string;
+} | {
+    names: string[];
+    links: {
+        id: string;
+        source: string;
+        target: string;
+        value: number | null;
+        datum: Row;
+    }[];
+    error?: undefined;
+};
+export declare const placeholderLinks: {
+    source: string;
+    target: string;
+    value: number;
+}[];

package/dist/cards/marimekko-blocks-card.d.ts

@@ -0,0 +1,10 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps } from './observations-card';
+export { marimekkoBlocksLayout } from './spatial-composition-layouts';
+export interface MarimekkoBlocksCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    category: TextKey<Row>;
+    segment: TextKey<Row>;
+    value: Key;
+    gap?: number;
+}
+export declare function MarimekkoBlocksCard<Row, const Key extends NumericKey<Row>>({ category, segment, value, gap, color, height, depth, ...props }: MarimekkoBlocksCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/observations-card.d.ts

@@ -1,7 +1,9 @@
 import { ReactNode } from 'react';
 import { CardLegend, ChartLegendSwatch, ChartLoadingStyle, ChartEmptyState, CategorySelection } from '../types';
 import { ChartCardProps } from './chart-card';
+import { ObservationPrism } from './prism';
 import { CardRange } from './cartesian-card';
+export type { ObservationPrism } from './prism';
 /** Shared presentation options for observation-based cards. */
 export interface ObservationsCardProps<Row> extends Omit<ChartCardProps, 'children'> {
     title?: string;
@@ -44,14 +46,52 @@ export interface ObservationMark<Row> {
     height: number;
     color: string;
     group?: string;
+    /** Neighbour mark IDs retained when this mark is inspected. */
+    related?: readonly string[];
     text?: string;
     detail?: string;
-    shape?: 'dot' | 'bar' | 'tile';
+    /** Extra context alongside the formatted numeric value; detail instead replaces it. */
+    description?: string;
+    shape?: 'dot' | 'bar' | 'tile' | 'prism' | 'point' | 'ribbon';
+    /** Closed SVG silhouette in local coordinates; also used for exact pointer hit testing. */
+    ribbon?: string;
+    /** Degrees clockwise about the mark's bottom centre, so a bar can point away from a centre. */
+    rotate?: number;
+    /** Stacking order where hit areas overlap: higher layers sit in front. */
+    layer?: number;
+    /** 0 to 1: where the mark falls in the order the chart builds, for entry and skeleton waves. */
+    wave?: number;
+    /** `grow` rises from the mark's foot; `drop` falls into place from above. */
+    enter?: 'grow' | 'drop';
+    /** A square prism seen from above, filling the mark's box: its top sits `lift` above the floor. */
+    prism?: ObservationPrism;
     missing?: boolean;
     future?: boolean;
 }
 export interface ObservationScene<Row> {
     marks: ObservationMark<Row>[];
+    /** Keep every segment of an inspected series lit. */
+    highlightGroup?: boolean;
+    /** A family-specific resting summary, calculated from accepted data. */
+    headline?: number | null;
+    /** Shapes painted under the marks, in order; `group` mutes with the active mark's group. */
+    paths?: {
+        id: string;
+        d: string;
+        fill?: string;
+        stroke?: string;
+        group?: string;
+        /** Endpoint IDs: this path stays lit when either endpoint is inspected. */
+        related?: readonly string[];
+        /** `rise` grows up from the shape's baseline; `draw` strokes along the path. */
+        enter?: 'rise' | 'draw';
+        /** 0 to 1: the order shapes build in. */
+        wave?: number;
+        /** The shape it grows from on entry, such as a surface laid flat on its floor. */
+        from?: string;
+        /** 0 lit to 1 in shade, so the placeholder keeps the scene's light. */
+        shade?: number;
+    }[];
     labels?: {
         x: number;
         y: number;
@@ -64,6 +104,7 @@ export interface ObservationScene<Row> {
         label: string;
         value: number | null;
         detail?: string;
+        description?: string;
     }[];
     groups?: {
         id: string;
@@ -80,8 +121,10 @@ export declare const seriesColor: (index: number) => string;
 export declare const readField: (row: unknown, key: string) => unknown;
 export declare const readNumber: (row: unknown, key: string) => number | null;
 /** Private shell: every family uses the same inspection, card and skeleton lifecycle. */
-export declare function ObservationsCard<Row>({ title, header, data: suppliedData, height, depth, headline, aggregate, delta, deltaTone, range, ranges, defaultRange, valueFormat, locale, formatValue, legend, legendSwatch, loading, loadingStyle, empty: emptyState, onSelectionChange, renderReadout, motion, className, color, layout, placeholder, family, ...frame }: ObservationsCardProps<Row> & {
+export declare function ObservationsCard<Row>({ title, header, data: suppliedData, height, depth, headline, aggregate, delta, deltaTone, range, ranges, defaultRange, valueFormat, locale, formatValue, legend, legendSwatch, loading, loadingStyle, empty: emptyState, onSelectionChange, renderReadout, motion, className, color, layout, placeholder, family, scope, renderControls, ...frame }: ObservationsCardProps<Row> & {
     family: string;
+    scope?: string;
+    renderControls?: (scene: ObservationScene<Row>, active: ObservationMark<Row> | undefined) => ReactNode;
     layout: (data: readonly Row[], width: number, height: number) => ObservationScene<Row>;
     placeholder: (width: number, height: number) => ObservationScene<Row>;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/cards/parallel-ribbons-card.d.ts

@@ -0,0 +1,27 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface ParallelRibbonsCardProps<Row, Key extends NumericKey<Row>> extends Omit<ObservationsCardProps<Row>, 'aggregate'> {
+    label: TextKey<Row>;
+    /** Two or more numeric keys, ordered left to right. Each axis has its own scale. */
+    metrics: readonly Key[];
+    /** Optional display names for the metric keys. */
+    metricLabels?: Partial<Record<Key, string>>;
+    /** Fixed domains must contain all readings on their axis. */
+    domains?: Partial<Record<Key, readonly [number, number]>>;
+    /** Ribbon width in pixels, 2–14. Default 5. */
+    thickness?: number;
+}
+export declare const placeholderProfiles: {
+    name: string;
+    speed: number;
+    quality: number;
+    cost: number;
+    reach: number;
+}[];
+export declare function parallelRibbonsLayout<Row>(data: readonly Row[], label: string, metrics: readonly string[], width: number, height: number, options?: {
+    thickness?: number;
+    color?: string;
+    metricLabels?: Readonly<Record<string, string | undefined>>;
+    domains?: Readonly<Record<string, readonly [number, number] | undefined>>;
+}): ObservationScene<Row>;
+export declare function ParallelRibbonsCard<Row, const Key extends NumericKey<Row>>({ label, metrics, metricLabels, domains, thickness, color, height, ...props }: ParallelRibbonsCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/prism-grid.d.ts

@@ -0,0 +1,58 @@
+import { ObservationMark, ObservationScene } from './observations-card';
+/** One grid cell for a prism layout: everything but its geometry. */
+export interface PrismCell<Row> extends Omit<ObservationMark<Row>, 'x' | 'y' | 'width' | 'height' | 'shape' | 'prism'> {
+    column: number;
+    row: number;
+    /** Position of the value in the domain, 0 to 1; ignored for missing and future cells. */
+    share: number;
+}
+export interface PrismGridOptions {
+    /** The tallest cell rises this many cell lengths above the floor. Default 5. */
+    rise?: number;
+    /** Space between neighbouring prisms as a share of a cell, 0 to 0.6. Default 0.2. */
+    gap?: number;
+}
+/**
+ * Columns recede shallowly to the right and rows more steeply toward the viewer, so a long grid
+ * reads as a low street rather than a steep isometric strip.
+ */
+export declare const COLUMN_AXIS: readonly [number, number];
+export declare const ROW_AXIS: readonly [number, number];
+/** Screen offset of a floor point `x` along the columns and `y` along the rows, `z` up. */
+export declare const project: (x: number, y: number, z?: number) => readonly [number, number];
+/**
+ * Stands a grid of cells up as square prisms seen from above and in front. Height and color both
+ * carry the value; missing cells keep a low slab on the floor and future cells lie flat as
+ * outlines. Column labels run along the front edge, row labels along the right end.
+ */
+export declare function prismGridLayout<Row>(cells: readonly PrismCell<Row>[], columns: number, rows: number, width: number, height: number, { rise, gap, columnLabels, rowLabels, note, }: PrismGridOptions & {
+    columnLabels?: readonly {
+        column: number;
+        text: string;
+    }[];
+    rowLabels?: readonly {
+        row: number;
+        text: string;
+    }[];
+    note?: string;
+}): ObservationScene<Row>;
+/** A prism described on the floor: its footprint in floor units, where it starts and how tall. */
+export interface FloorPrism<Row> extends Omit<ObservationMark<Row>, 'x' | 'y' | 'width' | 'height' | 'shape' | 'prism'> {
+    footprint: readonly (readonly [number, number])[];
+    /** Height of its floor and of the prism itself, in floor units. */
+    base: number;
+    rise: number;
+    depth: number;
+    wave: number;
+}
+/** Scales a set of floor prisms to fill the card, centred, and turns each into a prism mark. */
+export declare function fitFloorPrisms<Row>(items: readonly FloorPrism<Row>[], width: number, height: number, { headroom, below }?: {
+    headroom?: number;
+    below?: number;
+}): {
+    marks: ObservationMark<Row>[];
+    scale: number;
+    width: number;
+    height: number;
+    toScreen: (x: number, y: number, z?: number) => readonly [number, number];
+};

package/dist/cards/prism.d.ts

@@ -0,0 +1,42 @@
+type Point = readonly [number, number];
+/**
+ * A prism standing on the floor, seen from above and in front. `top` is its convex top face in
+ * the mark's box, already lifted; the floor sits `lift` pixels below it.
+ */
+export interface ObservationPrism {
+    top: readonly Point[];
+    /** Height above the floor in pixels. */
+    lift: number;
+    /** Painter's order: nearer prisms have a larger depth and cover farther ones. */
+    depth: number;
+    /** 0 at the back of the scene to 1 at the front, for the rising stagger. */
+    wave: number;
+}
+/** The prism's silhouette in its box, for hit testing and the loading mask. */
+export declare const prismOutline: ({ top, lift }: ObservationPrism) => Point[];
+/**
+ * The side faces a viewer above and in front can see: edges whose outward normal points down the
+ * screen. `shade` runs from 0 for a face turned to the light (left) to 1 for one turned away.
+ */
+export declare function visibleFaces({ top }: ObservationPrism): {
+    left: Point;
+    width: number;
+    angle: number;
+    shade: number;
+}[];
+/**
+ * Lit from above and to the left, like Lilt's isometric bars: the top is brightest, faces turned
+ * to the light are lit and faces turned away fall into shade. Each side is a skewed rectangle so
+ * it can rise from the floor on entry while the top travels up with it.
+ */
+export declare function Prism({ prism }: {
+    prism: ObservationPrism;
+}): import("react/jsx-runtime").JSX.Element;
+/** The loading prism: the same faces in skeleton tones, or its silhouette for the shimmer mask. */
+export declare function PrismSkeleton({ prism, x, y, painted, }: {
+    prism: ObservationPrism;
+    x: number;
+    y: number;
+    painted: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cards/progress-forms.d.ts

@@ -0,0 +1,21 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface GoalPacingCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    /** Numeric elapsed period, e.g. day of the quarter. */
+    x: NumericKey<Row>;
+    actual: Key;
+    expected: Key;
+    /** Explicit current period; this chart never consults the wall clock. */
+    at: number;
+    target: number;
+}
+export interface MilestoneProgressCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    label: TextKey<Row>;
+    position: Key;
+    current: number | null;
+    target?: number;
+}
+export declare function pacingLayout<Row>(data: readonly Row[], x: string, actual: string, expected: string, at: number, target: number, width: number, height: number, format?: (value: number) => string): ObservationScene<Row>;
+export declare function milestoneLayout<Row>(data: readonly Row[], label: string, position: string, current: number | null, target: number, width: number, height: number): ObservationScene<Row>;
+export declare function GoalPacingCard<Row, const Key extends NumericKey<Row>>({ x, actual, expected, at, target, ...props }: GoalPacingCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;
+export declare function MilestoneProgressCard<Row, const Key extends NumericKey<Row>>({ label, position, current, target, height, ...props }: MilestoneProgressCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/rank-ribbons-card.d.ts

@@ -0,0 +1,22 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface RankRibbonsCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    series: TextKey<Row>;
+    period: TextKey<Row>;
+    value: Key;
+    /** Descending puts the largest score first; ascending puts the smallest first. */
+    order?: 'descending' | 'ascending';
+    /** Ribbon width in pixels, 3–18. Default 10. */
+    thickness?: number;
+}
+export declare const placeholderRanks: {
+    team: string;
+    month: string;
+    score: number;
+}[];
+export declare function rankRibbonsLayout<Row>(data: readonly Row[], series: string, period: string, value: string, width: number, height: number, options?: {
+    order?: 'descending' | 'ascending';
+    thickness?: number;
+    color?: string;
+}): ObservationScene<Row>;
+export declare function RankRibbonsCard<Row, const Key extends NumericKey<Row>>({ series, period, value, order, thickness, color, height, aggregate, ...props }: RankRibbonsCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/ridgeline-card.d.ts

@@ -0,0 +1,24 @@
+import { NumericKey, TextKey, XKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface RidgelineCardProps<Row, Key extends NumericKey<Row>> extends Omit<ObservationsCardProps<Row>, 'legend' | 'legendSwatch'> {
+    /** One ridge per series, back to front in first-seen order. */
+    series: TextKey<Row>;
+    /** Position along each ridge, in first-seen order. */
+    x: XKey<Row>;
+    value: Key;
+    /** How many rows the tallest peak rises over the ridges behind it. Default 2.2. */
+    overlap?: number;
+    /** Fixed value domain that must contain every value. Defaults to zero through the largest. */
+    domain?: readonly [number, number];
+}
+/**
+ * Layered distributions receding into depth. Each series is a ridge that rises over the ones
+ * behind it and hides them where it is taller, so the shape of every row reads at a glance while
+ * every value stays inspectable.
+ */
+export declare function ridgelineLayout<Row>(data: readonly Row[], series: string, x: string, value: string, width: number, height: number, options?: {
+    overlap?: number;
+    domain?: readonly [number, number];
+    color?: string;
+}): ObservationScene<Row>;
+export declare function RidgelineCard<Row, const Key extends NumericKey<Row>>({ series, x, value, overlap, domain, color, height, ...props }: RidgelineCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/scatter-chart-card.d.ts

@@ -31,6 +31,10 @@ export interface ScatterChartCardProps<Row, Key extends NumericKey<Row>> {
     yLabel?: string;
     /** A least-squares line through the points, with its r² in the footer. */
     trend?: boolean;
+    /** Connect successive observations in each group. Missing coordinates break the trail. */
+    trails?: boolean;
+    /** Numeric time/order field for trails. Defaults to the supplied row order. */
+    trailOrder?: NumericKey<Row>;
     /** Draws each point as a lit sphere with a soft contact shadow; centers and sizes stay exact. */
     depth?: boolean;
     /** Plot height in pixels, including the axes. Defaults to 260. */
@@ -82,6 +86,20 @@ export interface ScatterChartCardProps<Row, Key extends NumericKey<Row>> {
     className?: string;
     style?: CSSProperties | ChartStyle;
 }
+/** Keep input identity and never bridge an unknown reading or an ambiguous duplicate time. */
+export declare function scatterTrails<T extends {
+    id: string;
+    group: string | null;
+    x: number | null;
+    y: number | null;
+    order: number | null;
+}>(rows: readonly T[]): [T & {
+    x: number;
+    y: number;
+}, T & {
+    x: number;
+    y: number;
+}][];
 /**
  * A readable domain for one axis: rounded to the same ticks the axis draws, anchored at zero when
  * the data starts near it, and never zero-width.
@@ -109,4 +127,4 @@ export declare function clipTrend(fit: {
  * and colored by group. Hovering or stepping through points with the arrow keys reads each one in
  * the headline, with its position marked on both axes.
  */
-export declare function ScatterChartCard<Row, const Key extends NumericKey<Row>>({ title, header, 'aria-label': ariaLabel, data: suppliedData, x, y, size, sizeLabel, group, label, xLabel, yLabel, trend, depth, height, aggregate, headline: suppliedHeadline, delta: suppliedDelta, deltaTone, range, ranges, defaultRange, valueFormat, legend, legendSwatch, xFormat, locale, formatValue: suppliedFormatValue, formatX: suppliedFormatX, color, surface, badge, numberStyle, palette, loading, loadingStyle, empty: emptyState, motion: motionMode, className, style, }: ScatterChartCardProps<Row, Key>): ReactElement;
+export declare function ScatterChartCard<Row, const Key extends NumericKey<Row>>({ title, header, 'aria-label': ariaLabel, data: suppliedData, x, y, size, sizeLabel, group, label, xLabel, yLabel, trend, trails, trailOrder, depth, height, aggregate, headline: suppliedHeadline, delta: suppliedDelta, deltaTone, range, ranges, defaultRange, valueFormat, legend, legendSwatch, xFormat, locale, formatValue: suppliedFormatValue, formatX: suppliedFormatX, color, surface, badge, numberStyle, palette, loading: pending, loadingStyle, empty: emptyState, motion: motionMode, className, style, }: ScatterChartCardProps<Row, Key>): ReactElement;

package/dist/cards/sculpted-geometry.d.ts

@@ -0,0 +1,18 @@
+import { ObservationMark, ObservationScene } from './observations-card';
+export type Point = readonly [number, number];
+export declare const fixed: (n: number) => number;
+export declare const xy: ([x, y]: Point) => string;
+export declare const polygon: (points: readonly Point[]) => string;
+export declare const clamp: (value: number | undefined, fallback: number, min: number, max: number) => number;
+export declare const identity: (...parts: (string | number)[]) => string;
+export declare const bad: <Row>(error: string) => ObservationScene<Row>;
+export declare const frame: (width: number, height: number) => {
+    width: number;
+    height: number;
+};
+/** A sampled ribbon keeps a closed silhouette for both paint and pointer hit testing. */
+export declare function ribbonMark<Row>(mark: Omit<ObservationMark<Row>, 'x' | 'y' | 'width' | 'height' | 'shape'>, points: readonly Point[]): ObservationMark<Row>;
+export declare function bezier(a: Point, b: Point, c: Point, d: Point, steps?: number): Point[];
+/** A constant-width ribbon around a polyline, with normals averaged at bends. */
+export declare function strokeRibbon(points: readonly Point[], width: number): Point[];
+export declare const tint: (color: string, percent: number) => string;

package/dist/cards/skyline-card.d.ts

@@ -0,0 +1,12 @@
+import { NumericKey } from './keys';
+import { ObservationScene } from './observations-card';
+import { CalendarHeatmapCardProps, CalendarOptions } from './calendar-heatmap-card';
+import { PrismGridOptions } from './prism-grid';
+export interface SkylineCardProps<Row, Key extends NumericKey<Row>> extends CalendarHeatmapCardProps<Row, Key>, PrismGridOptions {
+}
+/**
+ * A calendar stood up in three dimensions: weeks run away to the right, weekdays come toward the
+ * viewer, and each day is a prism whose height and color both carry its value.
+ */
+export declare function skylineLayout<Row>(data: readonly Row[], date: string, value: string, width: number, height: number, options?: CalendarOptions<Row> & PrismGridOptions): ObservationScene<Row>;
+export declare function SkylineCard<Row, const Key extends NumericKey<Row>>({ date, value, from, to, weekStartsOn, today, domain, rise, gap, color, locale, height, ...props }: SkylineCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/spatial-composition-layouts.d.ts

@@ -0,0 +1,14 @@
+import { Scene } from './spatial-geometry';
+export declare function windRoseLayout<Row>(data: readonly Row[], direction: string, band: string, value: string, width: number, height: number, options?: {
+    sectors?: number;
+    tilt?: number;
+    color?: string;
+}): Scene<Row>;
+export declare function marimekkoBlocksLayout<Row>(data: readonly Row[], category: string, segment: string, value: string, width: number, height: number, options?: {
+    gap?: number;
+    color?: string;
+}): Scene<Row>;
+export declare function intersectionTowersLayout<Row>(data: readonly Row[], members: string, value: string, width: number, height: number, options?: {
+    sort?: 'value' | 'input';
+    color?: string;
+}): Scene<Row>;

package/dist/cards/spatial-geometry.d.ts

@@ -0,0 +1,34 @@
+import { ObservationMark, ObservationScene } from './observations-card';
+import { polygon, Point } from './sculpted-geometry';
+export declare const TAU: number;
+export type XYZ = readonly [number, number, number];
+export type Scene<Row> = ObservationScene<Row>;
+export declare const ink = "var(--lilt-muted)";
+export declare function names<Row>(data: readonly Row[], key: string): string[] | string;
+export declare function readings<Row>(data: readonly Row[], labels: readonly string[], key: string): {
+    id: string;
+    label: string;
+    value: number | null;
+}[];
+export declare const paint: (index: number, color?: string) => string;
+export declare const sum: (values: readonly (number | null)[]) => number;
+export declare const negative: <Row>(data: readonly Row[], key: string) => boolean;
+export declare function sector(cx: number, cy: number, inner: number, outer: number, start: number, end: number, tilt?: number): Point[];
+/** Orthographic camera: metric axes stay linear; z remains vertical during yaw. */
+export declare function camera(width: number, height: number, yaw?: number, elevation?: number): (p: XYZ) => {
+    x: number;
+    y: number;
+    depth: number;
+    scale: number;
+    lift: number;
+};
+export declare function normalize(values: readonly (number | null)[]): {
+    low: number;
+    high: number;
+    at: (v: number) => number;
+};
+export declare function axes<Row>(project: ReturnType<typeof camera>, keys: readonly string[]): Pick<Scene<Row>, 'paths' | 'labels'>;
+export declare function cube<Row>(mark: Omit<ObservationMark<Row>, 'x' | 'y' | 'width' | 'height'>, p: XYZ, radius: number, project: ReturnType<typeof camera>): ObservationMark<Row>;
+export declare function slab<Row>(mark: Omit<ObservationMark<Row>, 'x' | 'y' | 'width' | 'height'>, x: number, y: number, width: number, height: number, lift: number): ObservationMark<Row>;
+export declare function ribbon<Row>(mark: Omit<ObservationMark<Row>, 'x' | 'y' | 'width' | 'height' | 'shape'>, points: readonly Point[]): ObservationMark<Row>;
+export { polygon };

package/dist/cards/spatial-hierarchy.d.ts

@@ -0,0 +1,10 @@
+export interface Branch<Row> {
+    id: string;
+    label: string;
+    depth: number;
+    value: number;
+    datum: Row | null;
+    children: Branch<Row>[];
+}
+/** Leaf-only paths avoid ambiguous parent totals and reject ancestor/leaf collisions. */
+export declare function hierarchy<Row>(data: readonly Row[], path: string, value: string): Branch<Row> | string;

package/dist/cards/spatial-point-layouts.d.ts

@@ -0,0 +1,16 @@
+import { Scene } from './spatial-geometry';
+export interface SpatialOptions {
+    yaw?: number;
+    elevation?: number;
+    size?: number;
+    color?: string;
+    group?: string;
+    slice?: readonly [number, number];
+}
+export declare function voxelCloudLayout<Row>(data: readonly Row[], label: string, x: string, y: string, z: string, value: string, width: number, height: number, options?: SpatialOptions): Scene<Row>;
+export declare function clusterConstellationLayout<Row>(data: readonly Row[], label: string, x: string, y: string, z: string, value: string, connections: string, width: number, height: number, options?: SpatialOptions): Scene<Row>;
+export declare function ternaryPrismLayout<Row>(data: readonly Row[], label: string, a: string, b: string, c: string, value: string, width: number, height: number, options?: {
+    tilt?: number;
+    rise?: number;
+    color?: string;
+}): Scene<Row>;

package/dist/cards/spatial-series-layouts.d.ts

@@ -0,0 +1,12 @@
+import { Scene } from './spatial-geometry';
+export declare function horizonFoldsLayout<Row>(data: readonly Row[], series: string, time: string, value: string, width: number, height: number, options?: {
+    bands?: number;
+    color?: string;
+}): Scene<Row>;
+export declare function helixRibbonsLayout<Row>(data: readonly Row[], series: string, cycle: string, phase: string, value: string, width: number, height: number, options?: {
+    yaw?: number;
+    elevation?: number;
+    thickness?: number;
+    maxGap?: number;
+    color?: string;
+}): Scene<Row>;

package/dist/cards/spiral-year-card.d.ts

@@ -0,0 +1,17 @@
+import { NumericKey, TimeKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface SpiralYearCardProps<Row, Key extends NumericKey<Row>> extends Omit<ObservationsCardProps<Row>, 'legend' | 'legendSwatch'> {
+    date: TimeKey<Row>;
+    value: Key;
+    /** Inclusive UTC date bounds. Default to the observed range; at most ten years. */
+    from?: string | number | Date;
+    to?: string | number | Date;
+    /** Fixed value domain that must contain every value. Defaults to zero through the largest. */
+    domain?: readonly [number, number];
+}
+/**
+ * Time as a coil: one turn per year with January at the top, so the same season lines up on every
+ * turn. Each day is a bar standing out from the coil whose length and color carry its value.
+ */
+export declare function spiralLayout<Row>(data: readonly Row[], date: string, value: string, width: number, height: number, options?: Pick<SpiralYearCardProps<Row, NumericKey<Row>>, 'from' | 'to' | 'domain' | 'color' | 'locale'>): ObservationScene<Row>;
+export declare function SpiralYearCard<Row, const Key extends NumericKey<Row>>({ date, value, from, to, domain, color, locale, height, ...props }: SpiralYearCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/sunburst-terraces-card.d.ts

@@ -0,0 +1,10 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps } from './observations-card';
+export { sunburstTerracesLayout } from './hierarchy-layouts';
+export interface SunburstTerracesCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    path: TextKey<Row>;
+    value: Key;
+    tilt?: number;
+    rise?: number;
+}
+export declare function SunburstTerracesCard<Row, const Key extends NumericKey<Row>>({ path, value, tilt, rise, color, height, depth, ...props }: SunburstTerracesCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/ternary-prism-card.d.ts

@@ -0,0 +1,13 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps } from './observations-card';
+export { ternaryPrismLayout } from './spatial-point-layouts';
+export interface TernaryPrismCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    label: TextKey<Row>;
+    a: NumericKey<Row>;
+    b: NumericKey<Row>;
+    c: NumericKey<Row>;
+    value: Key;
+    tilt?: number;
+    rise?: number;
+}
+export declare function TernaryPrismCard<Row, const Key extends NumericKey<Row>>({ label, a, b, c, value, tilt, rise, color, height, depth, ...props }: TernaryPrismCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/terrain-card.d.ts

@@ -0,0 +1,21 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface TerrainCardProps<Row, Key extends NumericKey<Row>> extends Omit<ObservationsCardProps<Row>, 'legend' | 'legendSwatch'> {
+    /** Columns, running away to the right, in first-seen order. */
+    x: TextKey<Row>;
+    /** Rows, coming toward the viewer, in first-seen order. */
+    y: TextKey<Row>;
+    value: Key;
+    /** How many cell lengths the highest value rises, default 3. */
+    rise?: number;
+    /** Surface samples between neighbouring readings, 1 to 6, default 4. Higher is smoother. */
+    smoothing?: number;
+    /** Fixed value domain that must contain every value. Defaults to zero through the largest. */
+    domain?: readonly [number, number];
+}
+/**
+ * A grid of readings as a lit landscape. The surface passes through every reading, peaks catch
+ * the light and slopes facing away fall into shade, and hovering drops a pin onto the reading.
+ */
+export declare function terrainLayout<Row>(data: readonly Row[], x: string, y: string, value: string, width: number, height: number, options?: Pick<TerrainCardProps<Row, NumericKey<Row>>, 'rise' | 'smoothing' | 'domain' | 'color'>): ObservationScene<Row>;
+export declare function TerrainCard<Row, const Key extends NumericKey<Row>>({ x, y, value, rise, smoothing, domain, color, height, ...props }: TerrainCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/treemap-chart-card.d.ts

@@ -7,6 +7,8 @@ export interface TreemapChartCardProps<Row, Key extends NumericKey<Row>> extends
     value: Key;
     /** Optional parent category. Input rows are leaves, never parent totals. */
     group?: TextKey<Row>;
+    /** Explore a parent group, with a breadcrumb back to all leaves. */
+    drilldown?: boolean;
 }
 interface Rect {
     x: number;
@@ -20,5 +22,5 @@ export declare function tileAreas<T>(items: readonly T[], weight: (item: T) => n
     rect: Rect;
 }[];
 export declare function treemapLayout<Row>(data: readonly Row[], label: string, value: string, group: string | undefined, width: number, height: number, color?: string): ObservationScene<Row>;
-export declare function TreemapChartCard<Row, const Key extends NumericKey<Row>>({ label, value, group, color, ...props }: TreemapChartCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;
+export declare function TreemapChartCard<Row, const Key extends NumericKey<Row>>({ label, value, group, color, drilldown, ...props }: TreemapChartCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/cards/trend-forms.d.ts

@@ -0,0 +1,11 @@
+import { CardSeries } from './cartesian-card';
+import { NumericKey, XKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface StreamgraphCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    x: XKey<Row>;
+    series: readonly CardSeries<Key>[];
+    curve?: 'smooth' | 'linear';
+}
+/** A centered, additive silhouette. Nonnegative thicknesses share one interpolator. */
+export declare function streamgraphLayout<Row>(data: readonly Row[], x: string, series: readonly CardSeries<string>[], curve: 'smooth' | 'linear', width: number, height: number): ObservationScene<Row>;
+export declare function StreamgraphCard<Row, const Key extends NumericKey<Row>>({ x, series, curve, ...props }: StreamgraphCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/voxel-cloud-card.d.ts

@@ -0,0 +1,16 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps } from './observations-card';
+export { voxelCloudLayout } from './spatial-point-layouts';
+export interface VoxelCloudCardProps<Row, Key extends NumericKey<Row>> extends ObservationsCardProps<Row> {
+    label: TextKey<Row>;
+    x: NumericKey<Row>;
+    y: NumericKey<Row>;
+    z: NumericKey<Row>;
+    value: Key;
+    group?: TextKey<Row>;
+    yaw?: number;
+    elevation?: number;
+    size?: number;
+    slice?: readonly [number, number];
+}
+export declare function VoxelCloudCard<Row, const Key extends NumericKey<Row>>({ label, x, y, z, value, group, yaw, elevation, size, slice, color, height, depth, ...props }: VoxelCloudCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;

package/dist/cards/voxel-waffle-card.d.ts

@@ -0,0 +1,18 @@
+import { NumericKey, TextKey } from './keys';
+import { ObservationsCardProps, ObservationScene } from './observations-card';
+export interface VoxelWaffleCardProps<Row, Key extends NumericKey<Row>> extends Omit<ObservationsCardProps<Row>, 'legendSwatch'> {
+    category: TextKey<Row>;
+    value: Key;
+    /** How many cubes make the whole, default 100. */
+    units?: number;
+    /** Cubes along each side of a layer, default 5. */
+    footprint?: number;
+}
+/** Whole cubes per category that add up to exactly `units`, by largest remainder. */
+export declare function allocateUnits(values: readonly number[], units: number): number[];
+/**
+ * Shares of a whole as a block of cubes: each category fills its share of `units` cubes, layer by
+ * layer from the floor up, so the block reads like a stacked waffle you can count.
+ */
+export declare function voxelLayout<Row>(data: readonly Row[], category: string, value: string, width: number, height: number, options?: Pick<VoxelWaffleCardProps<Row, NumericKey<Row>>, 'units' | 'footprint' | 'color'>): ObservationScene<Row>;
+export declare function VoxelWaffleCard<Row, const Key extends NumericKey<Row>>({ category, value, units, footprint, color, height, ...props }: VoxelWaffleCardProps<Row, Key>): import("react/jsx-runtime").JSX.Element;