@lilt-ui/charts 0.9.2 → 0.10.0

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;
+};