@lilt-ui/charts 0.9.2 → 0.11.0

package/dist/lifecycle/chart-empty.d.ts

@@ -0,0 +1,29 @@
+import { ReactElement, ReactNode } from 'react';
+import { ChartEmptyLook, ChartEmptyState } from '../types';
+/** The outline a chart family lays behind its empty message with the `shape` look. */
+export type ChartEmptyShape = 'wave' | 'bars' | 'rows' | 'ring' | 'points' | 'tiles' | 'web' | 'flow';
+/** Set by a card around its chart, so the chart's empty slot draws the family's own outline. */
+export declare const EmptyShapeContext: import('react').Context<ChartEmptyShape>;
+export interface ChartEmptyProps {
+    /** `dots` (default) or the chart's own `shape`. */
+    look?: ChartEmptyLook;
+    /** The message. Defaults to the chart's own, e.g. "No data for this period". */
+    children?: ReactNode;
+}
+/**
+ * Lilt's empty state: a still look and one quiet line. Pass it to a chart's `empty` prop with your
+ * own words, e.g. `empty={<ChartEmpty>No visits yet</ChartEmpty>}`; inside a chart it takes the
+ * chart's shape and message.
+ */
+export declare function ChartEmpty({ look, children }: ChartEmptyProps): ReactElement;
+/**
+ * Where a chart's empty state sits. Over a plot it fills the plot area; in place of a card's body
+ * (`block`) it holds the body's height, so an empty card keeps its size. The outline defaults to
+ * the one the card around it names.
+ */
+export declare function EmptySlot({ state, shape: ownShape, message, block, }: {
+    state?: ChartEmptyState;
+    shape?: ChartEmptyShape;
+    message?: string;
+    block?: boolean;
+}): ReactElement | null;

package/dist/marks/contract.d.ts

@@ -60,5 +60,3 @@ export declare function markSeries<T>(mark: string, descriptors: readonly ChartS
 export declare function rowFields(row: NormalizedRow<unknown>, series: string, fields: readonly string[]): number[] | null;
 /** An observation's own color, falling back to the series color. */
 export declare function observationColor<T>(descriptor: ChartSeries<T>, row: NormalizedRow<T>, fallback: string): string;
-/** Rows whose x lies in the visible domain. */
-export declare function rowsInView<T>(snapshot: ChartSnapshot<T>): readonly NormalizedRow<T>[];

package/dist/motion/use-chart-motion.d.ts

@@ -5,6 +5,11 @@ export interface TimelineSpec {
     key: string | number;
     duration: number;
     active: boolean;
+    /**
+     * Run on Lilt's spring instead of the reveal ease, keeping its slight overshoot: progress may
+     * pass 1 briefly before it settles there. For marks that should land like physical objects.
+     */
+    spring?: boolean;
 }
 export declare function useChartTimeline(spec: TimelineSpec, reducedMotion: boolean): number;
 export { REVEAL_EASE };

package/dist/motion/use-departing.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Items that just left the data, kept for `duration` milliseconds so they can animate out
+ * instead of vanishing. Changes are detected by key, so a list rebuilt every render is fine, and
+ * each departing item keeps the last place it was drawn. Derived while rendering, so it is never
+ * missing for a frame before its exit starts; an item that comes back stops departing at once.
+ */
+export declare function useDeparting<T>(items: readonly T[], keyOf: (item: T) => string, duration: number): readonly T[];

package/dist/motion/use-snap-bars.d.ts

@@ -0,0 +1,27 @@
+import { BarGeometry } from '../engine/bars';
+/** One bar as drawn on a frame of a snap: its geometry and how far it has risen. */
+export interface SnapBar {
+    key: string;
+    bar: BarGeometry;
+    /** Share of the bar's height above its floor: 0 drained, 1 full; a spring may overshoot. */
+    rise: number;
+    opacity: number;
+    /** Gaussian blur in pixels while the bar arrives or leaves. */
+    blur: number;
+    leaving: boolean;
+}
+/** Closed-form damped spring from 0 to 1 that lands with a slight overshoot in about 0.55s. */
+export declare function snapSpring(seconds: number): number;
+/**
+ * Bars that behave like real objects when the set of bars changes, such as a new period: new
+ * bars rise out of the floor with a soft blur, leaving bars drain back into it and narrow toward
+ * where their gap closes, and the rest spring to their new places, widths and heights. Returns
+ * the frame to draw while that runs, and `null` when at rest, so ordinary updates and the first
+ * entrance are untouched. `pulse` counts snaps, to restart the plot's light motion blur.
+ */
+export declare function useSnapBars(bars: readonly BarGeometry[] | undefined, keyOf: (bar: BarGeometry) => string, enabled: boolean, 
+/** The chart is revealing its first data: every bar arrives the way new bars do. */
+entrance?: boolean): {
+    frame: SnapBar[] | null;
+    pulse: number;
+};