matterviz 0.3.5 → 0.3.7

package/dist/plot/scales.d.ts

@@ -17,7 +17,7 @@ export type PlotScaleFn = ScaleContinuousNumeric<number, number> | ScaleTime<num
 export declare function scale_arcsinh(threshold?: number): ArcsinhScale;
 export declare function generate_arcsinh_ticks(min: number, max: number, threshold?: number, count?: number): number[];
 export declare function create_scale(scale_type: ScaleType, domain: [number, number], output_range: [number, number]): ScaleContinuousNumeric<number, number> | ArcsinhScale;
-export declare function create_time_scale(domain: [number, number], output_range: [number, number]): ScaleTime<number, number, never>;
+export declare const create_time_scale: (domain: [number, number], output_range: [number, number]) => ScaleTime<number, number, never>;
 export declare function generate_ticks(domain: [number, number], scale_type: ScaleType, ticks_option: TicksOption | undefined, scale_fn: PlotScaleFn, // D3 scale function with .ticks() method
 options?: {
     format?: string;

package/dist/plot/scales.js

@@ -107,7 +107,7 @@ export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
     const ticks = [0];
     // Add positive ticks
     const pos_ticks = generate_positive_arcsinh_ticks(0, hi, safe_threshold, half_count);
-    ticks.push(...pos_ticks.filter((t) => t > 0));
+    ticks.push(...pos_ticks.filter((tick) => tick > 0));
     // Add negative ticks (mirror of positive)
     const neg_ticks = generate_positive_arcsinh_ticks(0, -lo, safe_threshold, half_count);
     ticks.push(...neg_ticks.filter((tick) => tick > 0).map((tick) => -tick));
@@ -116,13 +116,12 @@ export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
         // Add boundaries if not already present and we have room
         const sorted = dedupe_sort(ticks);
         if (sorted.length < count) {
-            // Prefer the boundary with larger absolute value (more visually distinct)
-            const abs_lo = Math.abs(lo);
-            const abs_hi = Math.abs(hi);
-            if (abs_hi >= abs_lo && !sorted.includes(hi))
-                ticks.push(hi);
-            else if (!sorted.includes(lo))
-                ticks.push(lo);
+            // Snap the larger-magnitude boundary to a clean power of 10 (raw extremes would render
+            // as long unrounded labels); keeps some coverage for very small tick counts.
+            const boundary = Math.abs(hi) >= Math.abs(lo) ? hi : lo;
+            const nice = Math.sign(boundary) * 10 ** Math.floor(Math.log10(Math.abs(boundary)));
+            if (Number.isFinite(nice) && nice !== 0 && !sorted.includes(nice))
+                ticks.push(nice);
         }
     }
     return dedupe_sort(ticks);
@@ -146,12 +145,10 @@ function generate_positive_arcsinh_ticks(min, max, threshold, count) {
         }
     }
     else {
-        // Large range: combine linear near zero with powers of 10
-        // Add domain boundaries to ensure endpoints are represented
-        // This prevents cases like min=50, max=500 only showing powers of 10 (100)
-        if (min > 0)
-            ticks.push(min);
-        ticks.push(max);
+        // Large range: combine linear near zero with powers of 10.
+        // Domain endpoints are intentionally NOT added as ticks: raw extremes render as long
+        // unrounded labels (e.g. 1325.8239811994677). Powers of 10 plus 2x/5x multiples below
+        // already give clean round ticks; pass axis.ticks/axis.format for custom labels.
         // Add threshold as a tick if in range
         if (threshold >= min && threshold <= max)
             ticks.push(threshold);
@@ -197,11 +194,9 @@ export function create_scale(scale_type, domain, output_range) {
     return scaleLinear().domain(domain).range(output_range);
 }
 // Create a time scale for time-based data
-export function create_time_scale(domain, output_range) {
-    return scaleTime()
-        .domain([new Date(domain[0]), new Date(domain[1])])
-        .range(output_range);
-}
+export const create_time_scale = (domain, output_range) => scaleTime()
+    .domain([new Date(domain[0]), new Date(domain[1])])
+    .range(output_range);
 // Unified tick generation function
 export function generate_ticks(domain, scale_type, ticks_option, scale_fn, // D3 scale function with .ticks() method
 options = {}) {
@@ -359,7 +354,8 @@ export function get_nice_data_range(points, get_value, limits, scale_type, paddi
         ]) // Ensure log domain > 0
         : scaleLinear().domain([data_min, data_max]);
     scale.nice();
-    return scale.domain();
+    const [nice_min = data_min, nice_max = data_max] = scale.domain();
+    return [nice_min, nice_max];
 }
 // Generate logarithmic ticks (from ScatterPlot)
 export function generate_log_ticks(min, max, ticks_option) {
@@ -400,9 +396,10 @@ export function get_tick_label(tick_value, ticks_option) {
 // Create a color scale function from configuration
 export function create_color_scale(color_scale_config, auto_color_range) {
     const scheme = typeof color_scale_config === `string` ? color_scale_config : color_scale_config.scheme;
-    const interpolator = (typeof d3_sc[scheme] === `function`
-        ? d3_sc[scheme]
-        : d3_sc.interpolateViridis);
+    const candidate_interpolator = Object.entries(d3_sc).find(([key]) => key === scheme)?.[1];
+    const interpolator = typeof candidate_interpolator === `function`
+        ? candidate_interpolator
+        : d3_sc.interpolateViridis;
     const [min_val, max_val] = (typeof color_scale_config === `string` ? undefined : color_scale_config.value_range) ??
         auto_color_range;
     const scale_type = typeof color_scale_config === `string` ? undefined : color_scale_config.type;

package/dist/plot/types.d.ts

@@ -1,26 +1,17 @@
 import type { D3SymbolName } from '../labels';
-import type { Vec2, Vec3 } from '../math';
+import type { Point2D, Point3D, Vec2, Vec3 } from '../math';
 import type DraggablePane from '../overlays/DraggablePane.svelte';
 import type { ComponentProps, Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
 import type { TweenOptions } from 'svelte/motion';
 export type { TweenOptions } from 'svelte/motion';
+import type { Sides } from './layout';
 import type PlotLegend from './PlotLegend.svelte';
 import type { TicksOption } from './scales';
-export type XyObj = {
-    x: number;
-    y: number;
-};
 export type XyShift = {
     x?: number;
     y?: number;
 };
-export type Sides = {
-    t?: number;
-    b?: number;
-    l?: number;
-    r?: number;
-};
 export type InitialRanges = {
     initial_x_range: Vec2;
     initial_x2_range: Vec2;
@@ -31,7 +22,7 @@ export type Point<Metadata = Record<string, unknown>> = {
     x: number;
     y: number;
     metadata?: Metadata;
-    offset?: XyObj;
+    offset?: Point2D;
 };
 export interface PointStyle {
     fill?: string;
@@ -57,10 +48,14 @@ export interface HoverStyle {
 }
 export interface LabelStyle {
     text?: string;
-    offset?: XyObj;
+    offset?: Point2D;
     font_size?: string;
     font_family?: string;
     auto_placement?: boolean;
+    size?: {
+        width: number;
+        height: number;
+    };
 }
 export interface BarStyle {
     color?: string;
@@ -84,8 +79,8 @@ export interface PlotPoint<Metadata = Record<string, unknown>> extends Point<Met
     point_style?: PointStyle;
     point_hover?: HoverStyle;
     point_label?: LabelStyle;
-    point_offset?: XyObj;
-    point_tween?: TweenOptions<XyObj>;
+    point_offset?: Point2D;
+    point_tween?: TweenOptions<Point2D>;
 }
 export type Markers = `line` | `points` | `line+points` | `none`;
 export interface DataSeries<Metadata = Record<string, unknown>> {
@@ -101,8 +96,8 @@ export interface DataSeries<Metadata = Record<string, unknown>> {
     point_style?: PointStyle[] | PointStyle;
     point_hover?: HoverStyle[] | HoverStyle;
     point_label?: LabelStyle[] | LabelStyle;
-    point_offset?: XyObj[] | XyObj;
-    point_tween?: TweenOptions<XyObj>;
+    point_offset?: Point2D[] | Point2D;
+    point_tween?: TweenOptions<Point2D>;
     visible?: boolean;
     label?: string;
     legend_group?: string;
@@ -184,7 +179,7 @@ export interface ArcsinhScaleConfig {
     threshold?: number;
 }
 export type ScaleType = `linear` | `log` | `arcsinh` | `time` | ArcsinhScaleConfig;
-export declare function is_scale_type_name(val: string): val is ScaleTypeName;
+export declare const is_scale_type_name: (val: string) => val is ScaleTypeName;
 export declare function get_scale_type_name(scale_type: ScaleType | undefined): ScaleTypeName;
 export declare function get_arcsinh_threshold(scale_type: ScaleType | undefined): number;
 export declare function is_time_scale(scale_type: ScaleType | undefined, format: string | undefined): boolean;
@@ -207,13 +202,18 @@ export interface LabelPlacementConfig {
     weights?: LabelPlacementWeights;
     leader_line_threshold?: number;
     max_labels?: number;
+    candidate_gap?: number;
+    max_neighbors?: {
+        count: number;
+        radius: number;
+    };
 }
 export type HoverConfig = {
     threshold_px: number;
 };
 export type LegendConfig = Omit<ComponentProps<typeof PlotLegend>, `series_data` | `on_drag_start` | `on_drag` | `on_drag_end`> & {
     margin?: number | Sides;
-    tween?: TweenOptions<XyObj>;
+    tween?: TweenOptions<Point2D>;
     responsive?: boolean;
     draggable?: boolean;
     axis_clearance?: number;
@@ -278,7 +278,7 @@ export interface BarSeries<Metadata = Record<string, unknown>> {
     point_style?: PointStyle[] | PointStyle;
     point_hover?: HoverStyle[] | HoverStyle;
     point_label?: LabelStyle[] | LabelStyle;
-    point_offset?: XyObj[] | XyObj;
+    point_offset?: Point2D[] | Point2D;
 }
 export interface TickLabelConfig {
     inside?: boolean;
@@ -294,7 +294,7 @@ export interface AxisOption {
     unit?: string;
 }
 export type Y2SyncMode = `none` | `synced` | `align`;
-export declare function is_y2_sync_mode(val: string): val is Y2SyncMode;
+export declare const is_y2_sync_mode: (val: string) => val is Y2SyncMode;
 export interface Y2SyncConfig {
     mode: Y2SyncMode;
     align_value?: number;
@@ -440,17 +440,10 @@ export declare const DEFAULT_GRID_STYLE: {
 export declare const DEFAULT_MARKERS: "line+points";
 export declare const DEFAULT_SERIES_COLORS: readonly ["#4e79a7", "#f28e2c", "#e15759", "#76b7b2", "#59a14f", "#edc949", "#af7aa1", "#ff9da7", "#9c755f", "#bab0ab"];
 export declare const DEFAULT_SERIES_SYMBOLS: readonly ["Circle", "Square", "Triangle", "Cross", "Diamond", "Star", "Wye"];
-export type XyzObj = {
-    x: number;
-    y: number;
-    z: number;
-};
 export interface ScatterPoint3D<Metadata = Record<string, unknown>> extends Point<Metadata> {
     z: number;
 }
-export interface DataSeries3D<Metadata = Record<string, unknown>> extends Omit<DataSeries<Metadata>, `x` | `y` | `y_axis` | `filtered_data`> {
-    x: readonly number[];
-    y: readonly number[];
+export interface DataSeries3D<Metadata = Record<string, unknown>> extends Omit<DataSeries<Metadata>, `y_axis` | `filtered_data`> {
     z: readonly number[];
     filtered_data?: InternalPoint3D<Metadata>[];
 }
@@ -471,8 +464,8 @@ export interface Surface3DConfig {
     z_fn?: (x: number, y: number) => number;
     u_range?: Vec2;
     v_range?: Vec2;
-    parametric_fn?: (u: number, v: number) => XyzObj;
-    points?: XyzObj[];
+    parametric_fn?: (u: number, v: number) => Point3D;
+    points?: Point3D[];
     triangles?: Vec3[];
     color?: string;
     color_fn?: (x: number, y: number, z: number) => string;
@@ -502,13 +495,8 @@ export interface DisplayConfig3D extends DisplayConfig {
     projection_opacity?: number;
     projection_scale?: number;
 }
-export interface Scatter3DHandlerProps<Metadata = Record<string, unknown>> {
-    x: number;
-    y: number;
+export interface Scatter3DHandlerProps<Metadata = Record<string, unknown>> extends Omit<HandlerProps<Metadata>, `x_axis` | `x2_axis` | `y_axis` | `y2_axis`> {
     z: number;
-    metadata?: Metadata | null;
-    label?: string | null;
-    series_idx: number;
     x_axis: AxisConfig3D;
     y_axis: AxisConfig3D;
     z_axis: AxisConfig3D;
@@ -516,7 +504,6 @@ export interface Scatter3DHandlerProps<Metadata = Record<string, unknown>> {
     y_formatted: string;
     z_formatted: string;
     color_value?: number | null;
-    fullscreen?: boolean;
 }
 export type Scatter3DHandlerEvent<Metadata = Record<string, unknown>> = Scatter3DHandlerProps<Metadata> & {
     event?: MouseEvent;
@@ -707,16 +694,13 @@ export type RefLine = RefLineBase & ({
     p2: [RefLineValue, RefLineValue];
 });
 export declare const REF_LINE_STYLE_DEFAULTS: Required<RefLineStyle>;
-export interface RefLine3DBase {
-    id?: string | number;
-    x_span?: [number | null, number | null];
-    y_span?: [number | null, number | null];
+type Ref3DBase = Omit<RefLineBase, `coord_mode` | `x_axis` | `y_axis` | `style` | `hover_style` | `annotation` | `on_click` | `on_hover`> & {
     z_span?: [number | null, number | null];
+};
+export interface RefLine3DBase extends Ref3DBase {
     style?: RefLineStyle;
-    visible?: boolean;
-    label?: string;
-    metadata?: Record<string, unknown>;
     hover_style?: RefLineStyle;
+    annotation?: RefLineAnnotation;
     on_click?: (event: {
         line_idx: number;
         line_id?: string | number;
@@ -725,10 +709,6 @@ export interface RefLine3DBase {
         line_idx: number;
         line_id?: string | number;
     } | null) => void;
-    z_index?: LayerZIndex;
-    show_in_legend?: boolean;
-    legend_group?: string;
-    annotation?: RefLineAnnotation;
 }
 export type RefLine3D = RefLine3DBase & ({
     type: `x-axis`;
@@ -758,16 +738,8 @@ export interface RefPlaneStyle {
     wireframe_color?: string;
     double_sided?: boolean;
 }
-export interface RefPlaneBase {
-    id?: string | number;
-    x_span?: [number | null, number | null];
-    y_span?: [number | null, number | null];
-    z_span?: [number | null, number | null];
+export interface RefPlaneBase extends Ref3DBase {
     style?: RefPlaneStyle;
-    visible?: boolean;
-    label?: string;
-    show_in_legend?: boolean;
-    metadata?: Record<string, unknown>;
 }
 export type RefPlane = RefPlaneBase & ({
     type: `xy`;

package/dist/plot/types.js

@@ -1,8 +1,6 @@
 // Type guard for select value narrowing (avoids unsafe casts)
 const SCALE_TYPE_NAMES = new Set([`linear`, `log`, `arcsinh`, `time`]);
-export function is_scale_type_name(val) {
-    return SCALE_TYPE_NAMES.has(val);
-}
+export const is_scale_type_name = (val) => SCALE_TYPE_NAMES.has(val);
 // Helper to normalize ScaleType to base type name
 export function get_scale_type_name(scale_type) {
     if (!scale_type)
@@ -34,9 +32,7 @@ export function is_time_scale(scale_type, format) {
 }
 // Type guard for select value narrowing (avoids unsafe casts)
 const Y2_SYNC_MODES = new Set([`none`, `synced`, `align`]);
-export function is_y2_sync_mode(val) {
-    return Y2_SYNC_MODES.has(val);
-}
+export const is_y2_sync_mode = (val) => Y2_SYNC_MODES.has(val);
 export const LINE_TYPES = [`solid`, `dashed`, `dotted`];
 // Define grid cell identifiers
 export const CELLS_3X3 = [

package/dist/plot/utils/label-placement.d.ts

@@ -1,4 +1,5 @@
-import type { AxisConfig, DataSeries, XyObj } from '..';
+import type { Point2D } from '../../math';
+import type { AxisConfig, DataSeries } from '..';
 import type { PlotScaleFn } from '../scales';
 import type { LabelPlacementConfig, LabelPlacementWeights } from '../types';
 export interface Rect {
@@ -21,13 +22,33 @@ interface AnchorInfo {
 interface LabelState extends Rect {
     anchor_idx: number;
 }
+export interface LabelSize {
+    width: number;
+    height: number;
+}
+export interface LeaderLineSegment {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export interface LeaderLineOptions {
+    point: Point2D;
+    point_radius: number;
+    label_center: Point2D;
+    label_size: LabelSize;
+    min_length?: number;
+    label_padding?: number;
+}
 export declare function parse_font_size(size_str?: string): number;
+export declare function estimate_label_size(text: string, font_size_str?: string): LabelSize;
 export declare function rect_overlap_area(a: Rect, b: Rect): number;
 export declare function rect_circle_overlap(rect: Rect, cx: number, cy: number, radius: number): number;
 export declare function segments_intersect(ax1: number, ay1: number, ax2: number, ay2: number, bx1: number, by1: number, bx2: number, by2: number): boolean;
 export declare function segment_rect_intersects(sx1: number, sy1: number, sx2: number, sy2: number, rect: Rect): boolean;
 export declare function rect_out_of_bounds_area(rect: Rect, bounds: PlotBounds): number;
-export declare function generate_candidates(ax: number, ay: number, point_radius: number, label_w: number, label_h: number, gap: number): XyObj[];
+export declare function label_leader_segment({ point, point_radius, label_center, label_size, min_length, label_padding, }: LeaderLineOptions): LeaderLineSegment | null;
+export declare function generate_candidates(ax: number, ay: number, point_radius: number, label_w: number, label_h: number, gap: number): Point2D[];
 export declare function compute_delta_energy(labels: LabelState[], anchors: AnchorInfo[], changed_idx: number, old_state: LabelState, new_state: LabelState, weights: Required<LabelPlacementWeights>, bounds: PlotBounds): number;
 export declare function compute_label_positions(filtered_series: DataSeries[], config: LabelPlacementConfig, scales: {
     x_scale_fn: PlotScaleFn;
@@ -43,5 +64,5 @@ export declare function compute_label_positions(filtered_series: DataSeries[], c
         l: number;
         r: number;
     };
-}): Record<string, XyObj>;
+}): Record<string, Point2D>;
 export {};

package/dist/plot/utils/label-placement.js

@@ -7,6 +7,14 @@ const DEFAULT_WEIGHTS = {
     distance: 0.5,
     bounds: 100,
 };
+const NEIGHBOR_CELL_OFFSETS = [-1, 0, 1];
+const copy_state = (target, source) => {
+    target.x = source.x;
+    target.y = source.y;
+    target.w = source.w;
+    target.h = source.h;
+    target.anchor_idx = source.anchor_idx;
+};
 export function parse_font_size(size_str) {
     if (!size_str)
         return 12;
@@ -16,6 +24,15 @@ export function parse_font_size(size_str) {
     const value = parseFloat(match[1]);
     return match[2] === `em` || match[2] === `rem` ? value * 16 : value;
 }
+export function estimate_label_size(text, font_size_str) {
+    const font_size = parse_font_size(font_size_str);
+    const label_lines = text.split(/\r?\n/);
+    const max_line_length = Math.max(...label_lines.map((line) => line.length));
+    return {
+        width: max_line_length * font_size * 0.6 + 10,
+        height: label_lines.length * font_size * 1.2,
+    };
+}
 // === Geometry helpers ===
 export function rect_overlap_area(a, b) {
     const ox = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));
@@ -64,6 +81,26 @@ export function rect_out_of_bounds_area(rect, bounds) {
         penalty += (rect.y + rect.h - bounds.max_y) * rect.w;
     return penalty;
 }
+export function label_leader_segment({ point, point_radius, label_center, label_size, min_length = 6, label_padding = 1, }) {
+    const delta_x = label_center.x - point.x;
+    const delta_y = label_center.y - point.y;
+    const center_distance = Math.hypot(delta_x, delta_y);
+    if (center_distance <= 0)
+        return null;
+    const unit_x = delta_x / center_distance;
+    const unit_y = delta_y / center_distance;
+    const start_x = point.x + unit_x * point_radius;
+    const start_y = point.y + unit_y * point_radius;
+    const half_width = label_size.width / 2 + label_padding;
+    const half_height = label_size.height / 2 + label_padding;
+    const edge_distance = Math.min(Math.abs(unit_x) > 0.001 ? half_width / Math.abs(unit_x) : Infinity, Math.abs(unit_y) > 0.001 ? half_height / Math.abs(unit_y) : Infinity);
+    const visible_length = center_distance - point_radius - edge_distance;
+    if (visible_length <= min_length)
+        return null;
+    const end_x = label_center.x - unit_x * edge_distance;
+    const end_y = label_center.y - unit_y * edge_distance;
+    return { x1: start_x, y1: start_y, x2: end_x, y2: end_y };
+}
 // 8 candidate positions around anchor: R, TR, T, TL, L, BL, B, BR
 // Positions are top-left corner of the label bounding box.
 // All positions keep a full `offset` gap from the marker edge.
@@ -131,6 +168,41 @@ export function compute_delta_energy(labels, anchors, changed_idx, old_state, ne
     }
     return delta;
 }
+function cull_dense_labels(label_infos, max_neighbors, radius) {
+    if (radius <= 0 || label_infos.length <= max_neighbors + 1)
+        return label_infos;
+    const radius_squared = radius * radius;
+    const get_cell = (value) => Math.floor(value / radius);
+    const grid = {};
+    label_infos.forEach(({ anchor }, label_idx) => {
+        const key = `${get_cell(anchor.x)},${get_cell(anchor.y)}`;
+        const bucket = grid[key] ?? (grid[key] = []);
+        bucket.push(label_idx);
+    });
+    return label_infos.filter(({ anchor }, label_idx) => {
+        const cell_x = get_cell(anchor.x);
+        const cell_y = get_cell(anchor.y);
+        let neighbors = 0;
+        for (const cell_x_offset of NEIGHBOR_CELL_OFFSETS) {
+            for (const cell_y_offset of NEIGHBOR_CELL_OFFSETS) {
+                const bucket = grid[`${cell_x + cell_x_offset},${cell_y + cell_y_offset}`];
+                if (!bucket)
+                    continue;
+                for (const neighbor_idx of bucket) {
+                    if (neighbor_idx === label_idx)
+                        continue;
+                    const delta_x = anchor.x - label_infos[neighbor_idx].anchor.x;
+                    const delta_y = anchor.y - label_infos[neighbor_idx].anchor.y;
+                    if (delta_x * delta_x + delta_y * delta_y <= radius_squared)
+                        neighbors += 1;
+                    if (neighbors > max_neighbors)
+                        return false;
+                }
+            }
+        }
+        return true;
+    });
+}
 // === Main export ===
 export function compute_label_positions(filtered_series, config, scales, bounds) {
     const { x_scale_fn, y_scale_fn, y2_scale_fn, x_axis } = scales;
@@ -142,7 +214,8 @@ export function compute_label_positions(filtered_series, config, scales, bounds)
         max_y: height - pad.b,
     };
     // Collect all label data in a single pass
-    const label_infos = [];
+    let label_infos = [];
+    const candidate_gap = config.candidate_gap ?? 4;
     for (const series of filtered_series) {
         for (const pt of series.filtered_data ?? []) {
             if (!pt.point_label?.auto_placement || !pt.point_label.text)
@@ -151,19 +224,23 @@ export function compute_label_positions(filtered_series, config, scales, bounds)
                 ? x_scale_fn(new Date(pt.x))
                 : x_scale_fn(pt.x);
             const ay = (series.y_axis === `y2` ? y2_scale_fn : y_scale_fn)(pt.y);
-            const font_size = parse_font_size(pt.point_label.font_size);
-            const label_w = pt.point_label.text.length * font_size * 0.6 + 10;
-            const label_h = font_size * 1.2;
+            const label_size = pt.point_label.size ??
+                estimate_label_size(pt.point_label.text, pt.point_label.font_size);
+            const label_w = label_size.width;
+            const label_h = label_size.height;
             const radius = pt.point_style?.radius ?? 3;
             label_infos.push({
                 id: `${pt.series_idx}-${pt.point_idx}`,
                 anchor: { x: ax, y: ay, radius },
                 width: label_w,
                 height: label_h,
-                candidates: generate_candidates(ax, ay, radius, label_w, label_h, 4),
+                candidates: generate_candidates(ax, ay, radius, label_w, label_h, candidate_gap),
             });
         }
     }
+    if (config.max_neighbors) {
+        label_infos = cull_dense_labels(label_infos, config.max_neighbors.count, config.max_neighbors.radius);
+    }
     const num_labels = label_infos.length;
     if (num_labels === 0)
         return {};
@@ -218,13 +295,6 @@ export function compute_label_positions(filtered_series, config, scales, bounds)
     // Reusable scratch objects to avoid allocations in the hot loop
     const old_scratch = { x: 0, y: 0, w: 0, h: 0, anchor_idx: 0 };
     const new_scratch = { x: 0, y: 0, w: 0, h: 0, anchor_idx: 0 };
-    const copy_state = (dst, src) => {
-        dst.x = src.x;
-        dst.y = src.y;
-        dst.w = src.w;
-        dst.h = src.h;
-        dst.anchor_idx = src.anchor_idx;
-    };
     for (let step = 0; step < total_steps; step++) {
         const temperature = Math.max(0.001, 1.0 - step * cooling_rate);
         const label_idx = Math.floor(next_random() * num_labels);

package/dist/plot/utils/series-visibility.d.ts

@@ -1,9 +1,15 @@
 import type { DataSeries } from '../types';
 export type StrRecord = Record<string, unknown>;
+type SeriesSource = [string, string, string, unknown, unknown];
+export type SeriesVisibilitySnapshot = {
+    visibility: boolean[];
+    source: SeriesSource[];
+};
 export declare function have_compatible_units<Metadata extends StrRecord = StrRecord>(series1: DataSeries<Metadata>, series2: DataSeries<Metadata>): boolean;
 export declare function toggle_series_visibility<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], series_idx: number): DataSeries<Metadata>[];
 export declare function toggle_group_visibility<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], series_indices: number[]): DataSeries<Metadata>[];
-export declare function handle_legend_double_click<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], idx: number, prev_visibility: boolean[] | null): {
+export declare function handle_legend_double_click<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], idx: number, prev_snapshot: SeriesVisibilitySnapshot | null): {
     series: DataSeries<Metadata>[];
-    previous_visibility: boolean[] | null;
+    prev_visibility: SeriesVisibilitySnapshot | null;
 };
+export {};

package/dist/plot/utils/series-visibility.js

@@ -1,3 +1,8 @@
+const series_source = (series, length = series.length) => series
+    .slice(0, length)
+    .map((srs) => [srs.label ?? ``, srs.unit ?? ``, srs.y_axis ?? ``, srs.x, srs.y]);
+const same_series_source = (series, snapshot_series) => series.length === snapshot_series.length &&
+    series.every((source, idx) => source.every((part, part_idx) => Object.is(part, snapshot_series[idx][part_idx])));
 export function have_compatible_units(series1, series2) {
     if (!series1.unit || !series2.unit)
         return true;
@@ -34,12 +39,18 @@ export function toggle_group_visibility(series, series_indices) {
     const new_visibility = !all_visible;
     return series.map((srs, idx) => idx_set.has(idx) ? { ...srs, visible: new_visibility } : srs);
 }
-export function handle_legend_double_click(series, idx, prev_visibility) {
+export function handle_legend_double_click(series, idx, prev_snapshot) {
     if (idx < 0 || idx >= series.length) {
-        return { series, previous_visibility: prev_visibility };
+        return { series, prev_visibility: prev_snapshot };
     }
     const { label } = series[idx];
     const current = series.map((srs) => srs.visible ?? true);
+    const current_source = prev_snapshot
+        ? series_source(series, prev_snapshot.visibility.length)
+        : [];
+    const prev_visibility = prev_snapshot && same_series_source(current_source, prev_snapshot.source)
+        ? prev_snapshot.visibility
+        : null;
     // Only check original series (ignore new ones added after isolation)
     const check_series = prev_visibility ? series.slice(0, prev_visibility.length) : series;
     const is_isolated = check_series.every((srs, srs_idx) => {
@@ -52,16 +63,23 @@ export function handle_legend_double_click(series, idx, prev_visibility) {
             series: series.map((srs, srs_idx) => srs_idx < prev_visibility.length && current[srs_idx] !== prev_visibility[srs_idx]
                 ? { ...srs, visible: prev_visibility[srs_idx] }
                 : srs),
-            previous_visibility: null,
+            prev_visibility: null,
         };
     }
     // Isolate series
-    const new_prev = prev_visibility ?? (current.filter(Boolean).length > 1 ? [...current] : null);
+    const new_prev = prev_visibility
+        ? prev_snapshot
+        : current.filter(Boolean).length > 1
+            ? {
+                visibility: [...current],
+                source: series_source(series),
+            }
+            : null;
     return {
         series: series.map((srs, srs_idx) => {
             const in_group = label ? srs.label === label : srs_idx === idx;
             return (srs.visible ?? true) !== in_group ? { ...srs, visible: in_group } : srs;
         }),
-        previous_visibility: new_prev,
+        prev_visibility: new_prev,
     };
 }

package/dist/rdf/RdfPlot.svelte

@@ -130,10 +130,10 @@
     for (const { struct, label } of struct_list) {
       if (mode === `element_pairs`) {
         const pairs = calculate_all_pair_rdfs(struct, { cutoff, n_bins, pbc })
-        result.push(...pairs.map((p) => ({
-          label: p.element_pair ? `${p.element_pair[0]}-${p.element_pair[1]}` : label,
+        result.push(...pairs.map((pair) => ({
+          label: pair.element_pair ? `${pair.element_pair[0]}-${pair.element_pair[1]}` : label,
           legend_group: label, // Group by structure name for multi-structure plots
-          pattern: p,
+          pattern: pair,
         })))
       } else {
         const pattern = calculate_rdf(struct, { cutoff, n_bins, pbc })
@@ -143,8 +143,8 @@
     return result
   })
 
-  const max_r = $derived(Math.max(...entries.flatMap((e) => e.pattern.r), 0))
-  const max_g = $derived(Math.max(1.2, ...entries.flatMap((e) => e.pattern.g_r)))
+  const max_r = $derived(Math.max(...entries.flatMap((entry) => entry.pattern.r), 0))
+  const max_g = $derived(Math.max(1.2, ...entries.flatMap((entry) => entry.pattern.g_r)))
 
   const series = $derived<DataSeries[]>(
     entries.map((ent, idx) => ({

package/dist/rdf/calc-rdf.js

@@ -1,5 +1,8 @@
 import { calc_lattice_params, create_lattice_converters, euclidean_dist, pbc_dist, } from '../math';
 import { make_supercell } from '../structure/supercell';
+const get_occu = (site, elem) => elem ? (site.species.find((spec) => spec.element === elem)?.occu ?? 0) : 1;
+const has_species = (site, elem) => !elem || site.species.some((spec) => spec.element === elem);
+const sum_occu = (sites, elem) => sites.reduce((sum, site) => sum + get_occu(site, elem), 0);
 // Calculate radial distribution function
 export function calculate_rdf(structure, options = {}) {
     const { center_species, neighbor_species, cutoff = 15, n_bins = 75, auto_expand = true, expansion_factor = 2.0, } = options;
@@ -33,8 +36,6 @@ export function calculate_rdf(structure, options = {}) {
     if (sites.length === 0)
         return { r, g_r };
     // Get occupancy weight for a site-species pair (supports mixed occupancy)
-    const get_occu = (site, elem) => elem ? (site.species.find((spec) => spec.element === elem)?.occu ?? 0) : 1;
-    const has_species = (site, elem) => !elem || site.species.some((spec) => spec.element === elem);
     const centers = sites.filter((site) => has_species(site, center_species));
     const neighbors = sites.filter((site) => has_species(site, neighbor_species));
     if (centers.length === 0 || neighbors.length === 0) {
@@ -61,7 +62,6 @@ export function calculate_rdf(structure, options = {}) {
         }
     }
     // Normalize using occupancy-weighted pair count (excludes self-interactions for same species)
-    const sum_occu = (arr, elem) => arr.reduce((sum, site) => sum + get_occu(site, elem), 0);
     const center_weight = sum_occu(centers, center_species);
     const neighbor_weight = sum_occu(neighbors, neighbor_species);
     const self_weight = center_species === neighbor_species